update 498

fishercoder1534 · fishercoder1534 · commit 27c1b1bfceb8 · 2024-06-09T10:58:28.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_498.java b/src/main/java/com/fishercoder/solutions/_498.java
@@ -10,41 +10,48 @@ public static class Solutoin1 {
         /**
          * Reference: https://discuss.leetcode.com/topic/77865/concise-java-solution/2
          * Just keep walking the matrix, when hitting the four borders (top, bottom, left or right),
-         * just directions and keep walking.
+         * change directions and keep walking:
+         * <p>
+         * if out of bottom border (i >= m), then i = m - 1, j += 2, change walk direction;
+         * if out of top border (i < 0), then i = 0, change walk direction;
+         * if out of left border (j < 0), then j = 0, change walk direction;
+         * if out of right border (j >= n), then j = n - 1, i += 2, change walk direction.
          */
-        public int[] findDiagonalOrder(int[][] matrix) {
-
-            if (matrix == null || matrix.length == 0) {
+        public int[] findDiagonalOrder(int[][] mat) {
+            if (mat == null || mat.length == 0) {
                 return new int[0];
             }
-            int m = matrix.length;
-            int n = matrix[0].length;
+            int m = mat.length;
+            int n = mat[0].length;
             int[] result = new int[m * n];
-            int d = 1;
+            //{-1,1} goes from top left to bottom right
+            //{1,-1} goes from top right to bottom left
+            int[][] dirs = new int[][]{{-1, 1}, {1, -1}};
             int i = 0;
             int j = 0;
+            int d = 0;
             for (int k = 0; k < m * n; ) {
-                result[k++] = matrix[i][j];
-                i -= d;
-                j += d;
+                result[k++] = mat[i][j];
+                i += dirs[d][0];
+                j += dirs[d][1];
 
                 if (i >= m) {
                     i = m - 1;
                     j += 2;
-                    d = -d;
+                    d = 1 - d;
                 }
                 if (j >= n) {
                     j = n - 1;
                     i += 2;
-                    d = -d;
+                    d = 1 - d;
                 }
                 if (i < 0) {
                     i = 0;
-                    d = -d;
+                    d = 1 - d;
                 }
                 if (j < 0) {
                     j = 0;
-                    d = -d;
+                    d = 1 - d;
                 }
             }
             return result;
@@ -87,5 +94,5 @@ public int[] findDiagonalOrder(int[][] matrix) {
             return result;
         }
     }
-    
+
 }
diff --git a/src/test/java/com/fishercoder/_498Test.java b/src/test/java/com/fishercoder/_498Test.java
@@ -1,10 +1,10 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._498;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
 /**
  * Created by fishercoder on 5/26/17.
@@ -15,8 +15,8 @@ public class _498Test {
     private static int[][] matrix;
     private static int[] expected;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeEach
+    public void setup() {
         solutoin1 = new _498.Solutoin1();
         solutoin2 = new _498.Solutoin2();
     }
