feat: add solutions to lc problem: No.0054

No.0054.Spiral Matrix

Author: yanglbme

solution/0000-0099/0054.Spiral Matrix/README.md

@@ -2,19 +2,20 @@ class Solution {
 public:
     vector<int> spiralOrder(vector<vector<int>>& matrix) {
         int m = matrix.size(), n = matrix[0].size();
-        int top = 0, bottom = m - 1, left = 0, right = n - 1;
+        int dirs[5] = {0, 1, 0, -1, 0};
+        int i = 0, j = 0, k = 0;
         vector<int> ans;
-        while (top <= bottom && left <= right) {
-            for (int j = left; j <= right; ++j) ans.push_back(matrix[top][j]);
-            for (int i = top + 1; i <= bottom; ++i) ans.push_back(matrix[i][right]);
-            if (left < right && top < bottom) {
-                for (int j = right - 1; j >= left; --j) ans.push_back(matrix[bottom][j]);
-                for (int i = bottom - 1; i > top; --i) ans.push_back(matrix[i][left]);
+        bool vis[m][n];
+        memset(vis, false, sizeof(vis));
+        for (int h = m * n; h; --h) {
+            ans.push_back(matrix[i][j]);
+            vis[i][j] = true;
+            int x = i + dirs[k], y = j + dirs[k + 1];
+            if (x < 0 || x >= m || y < 0 || y >= n || vis[x][y]) {
+                k = (k + 1) % 4;
             }
-            ++top;
-            --bottom;
-            ++left;
-            --right;
+            i += dirs[k];
+            j += dirs[k + 1];
         }
         return ans;
     }

solution/0000-0099/0054.Spiral Matrix/README_EN.md

@@ -1,34 +1,18 @@
 public class Solution {
     public IList<int> SpiralOrder(int[][] matrix) {
-        int m = matrix.Length;
-        int n = matrix[0].Length;
-        int top = 0, bottom = m - 1, left = 0, right = n - 1;
-        var ans = new List<int>(m * n);
-        while (top <= bottom && left <= right)
-        {
-            for (int j = left; j <= right; ++j)
-            {
-                ans.Add(matrix[top][j]);
+        int m = matrix.Length, n = matrix[0].Length;
+        int[] dirs = new int[] {0, 1, 0, -1, 0};
+        IList<int> ans = new List<int>();
+        bool[,] visited = new bool[m, n];
+        for (int h = m * n, i = 0, j = 0, k = 0; h > 0; --h) {
+            ans.Add(matrix[i][j]);
+            visited[i, j] = true;
+            int x = i + dirs[k], y = j + dirs[k + 1];
+            if (x < 0 || x >= m || y < 0 || y >= n || visited[x, y]) {
+                k = (k + 1) % 4;
             }
-            for (int i = top + 1; i <= bottom; ++i)
-            {
-                ans.Add(matrix[i][right]);
-            }
-            if (left < right && top < bottom)
-            {
-                for (int j = right - 1; j >= left; --j)
-                {
-                    ans.Add(matrix[bottom][j]);
-                }
-                for (int i = bottom - 1; i > top; --i)
-                {
-                    ans.Add(matrix[i][left]);
-                }
-            }
-            ++top;
-            --bottom;
-            ++left;
-            --right;
+            i += dirs[k];
+            j += dirs[k + 1];
         }
         return ans;
     }

solution/0000-0099/0054.Spiral Matrix/Solution.cpp

@@ -1,28 +1,19 @@
-func spiralOrder(matrix [][]int) []int {
+func spiralOrder(matrix [][]int) (ans []int) {
 	m, n := len(matrix), len(matrix[0])
-	ans := make([]int, 0, m*n)
-
-	top, bottom, left, right := 0, m-1, 0, n-1
-	for left <= right && top <= bottom {
-		for i := left; i <= right; i++ {
-			ans = append(ans, matrix[top][i])
-		}
-		for i := top + 1; i <= bottom; i++ {
-			ans = append(ans, matrix[i][right])
-		}
-		if left < right && top < bottom {
-			for i := right - 1; i >= left; i-- {
-				ans = append(ans, matrix[bottom][i])
-			}
-			for i := bottom - 1; i > top; i-- {
-				ans = append(ans, matrix[i][left])
-			}
+	vis := make([][]bool, m)
+	for i := range vis {
+		vis[i] = make([]bool, n)
+	}
+	dirs := [5]int{0, 1, 0, -1, 0}
+	i, j, k := 0, 0, 0
+	for h := m * n; h > 0; h-- {
+		ans = append(ans, matrix[i][j])
+		vis[i][j] = true
+		x, y := i+dirs[k], j+dirs[k+1]
+		if x < 0 || x >= m || y < 0 || y >= n || vis[x][y] {
+			k = (k + 1) % 4
 		}
-		top++
-		bottom--
-		left++
-		right--
+		i, j = i+dirs[k], j+dirs[k+1]
 	}
-
-	return ans
-}
+	return
+}

solution/0000-0099/0054.Spiral Matrix/Solution.cs

@@ -1,27 +1,19 @@
 class Solution {
     public List<Integer> spiralOrder(int[][] matrix) {
         int m = matrix.length, n = matrix[0].length;
-        int top = 0, bottom = m - 1, left = 0, right = n - 1;
+        int[] dirs = {0, 1, 0, -1, 0};
+        int i = 0, j = 0, k = 0;
         List<Integer> ans = new ArrayList<>();
-        while (left <= right && top <= bottom) {
-            for (int j = left; j <= right; ++j) {
-                ans.add(matrix[top][j]);
+        boolean[][] vis = new boolean[m][n];
+        for (int h = m * n; h > 0; --h) {
+            ans.add(matrix[i][j]);
+            vis[i][j] = true;
+            int x = i + dirs[k], y = j + dirs[k + 1];
+            if (x < 0 || x >= m || y < 0 || y >= n || vis[x][y]) {
+                k = (k + 1) % 4;
             }
-            for (int i = top + 1; i <= bottom; ++i) {
-                ans.add(matrix[i][right]);
-            }
-            if (left < right && top < bottom) {
-                for (int j = right - 1; j >= left; --j) {
-                    ans.add(matrix[bottom][j]);
-                }
-                for (int i = bottom - 1; i > top; --i) {
-                    ans.add(matrix[i][left]);
-                }
-            }
-            ++top;
-            --bottom;
-            ++left;
-            --right;
+            i += dirs[k];
+            j += dirs[k + 1];
         }
         return ans;
     }

solution/0000-0099/0054.Spiral Matrix/Solution.go

@@ -5,24 +5,19 @@
 var spiralOrder = function (matrix) {
     const m = matrix.length;
     const n = matrix[0].length;
-    let [top, bottom, left, right] = [0, m - 1, 0, n - 1];
-    let ans = [];
-    while (top <= bottom && left <= right) {
-        for (let j = left; j <= right; ++j) {
-            ans.push(matrix[top][j]);
+    const ans = [];
+    const vis = new Array(m).fill(0).map(() => new Array(n).fill(false));
+    const dirs = [0, 1, 0, -1, 0];
+    for (let h = m * n, i = 0, j = 0, k = 0; h > 0; --h) {
+        ans.push(matrix[i][j]);
+        vis[i][j] = true;
+        const x = i + dirs[k];
+        const y = j + dirs[k + 1];
+        if (x < 0 || x >= m || y < 0 || y >= n || vis[x][y]) {
+            k = (k + 1) % 4;
         }
-        for (let i = top + 1; i <= bottom; ++i) {
-            ans.push(matrix[i][right]);
-        }
-        if (left < right && top < bottom) {
-            for (let j = right - 1; j >= left; --j) {
-                ans.push(matrix[bottom][j]);
-            }
-            for (let i = bottom - 1; i > top; --i) {
-                ans.push(matrix[i][left]);
-            }
-        }
-        [top, bottom, left, right] = [top + 1, bottom - 1, left + 1, right - 1];
+        i += dirs[k];
+        j += dirs[k + 1];
     }
     return ans;
 };

solution/0000-0099/0054.Spiral Matrix/Solution.java

@@ -1,13 +1,16 @@
 class Solution:
     def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
         m, n = len(matrix), len(matrix[0])
+        dirs = (0, 1, 0, -1, 0)
+        i = j = k = 0
         ans = []
-        top, bottom, left, right = 0, m - 1, 0, n - 1
-        while left <= right and top <= bottom:
-            ans.extend([matrix[top][j] for j in range(left, right + 1)])
-            ans.extend([matrix[i][right] for i in range(top + 1, bottom + 1)])
-            if left < right and top < bottom:
-                ans.extend([matrix[bottom][j] for j in range(right - 1, left - 1, -1)])
-                ans.extend([matrix[i][left] for i in range(bottom - 1, top, -1)])
-            top, bottom, left, right = top + 1, bottom - 1, left + 1, right - 1
+        vis = set()
+        for _ in range(m * n):
+            ans.append(matrix[i][j])
+            vis.add((i, j))
+            x, y = i + dirs[k], j + dirs[k + 1]
+            if not 0 <= x < m or not 0 <= y < n or (x, y) in vis:
+                k = (k + 1) % 4
+            i = i + dirs[k]
+            j = j + dirs[k + 1]
         return ans

solution/0000-0099/0054.Spiral Matrix/Solution.js

@@ -1,23 +1,19 @@
 function spiralOrder(matrix: number[][]): number[] {
     const m = matrix.length;
     const n = matrix[0].length;
-    const res = [];
-    for (let i = 0; i <= m >> 1; i++) {
-        for (let j = i; j < n - i - 1; j++) {
-            res.push(matrix[i][j]);
+    const ans: number[] = [];
+    const vis = new Array(m).fill(0).map(() => new Array(n).fill(false));
+    const dirs = [0, 1, 0, -1, 0];
+    for (let h = m * n, i = 0, j = 0, k = 0; h > 0; --h) {
+        ans.push(matrix[i][j]);
+        vis[i][j] = true;
+        const x = i + dirs[k];
+        const y = j + dirs[k + 1];
+        if (x < 0 || x >= m || y < 0 || y >= n || vis[x][y]) {
+            k = (k + 1) % 4;
         }
-        for (let j = i; j < m - i - 1; j++) {
-            res.push(matrix[j][n - i - 1]);
-        }
-        for (let j = i; j < n - i - 1; j++) {
-            res.push(matrix[m - i - 1][n - j - 1]);
-        }
-        for (let j = i; j < m - i - 1; j++) {
-            res.push(matrix[m - j - 1][i]);
-        }
-    }
-    if (m & 1) {
-        res.push(matrix[m >> 1][n >> 1]);
+        i += dirs[k];
+        j += dirs[k + 1];
     }
-    return res.slice(0, m * n);
+    return ans;
 }