LeetCode: Spiral Matrix

多数次过。很奇怪dfs函数声明的时候形参里dir[][]不能用，必须为dir[4][2].

 1 class Solution {

 2 public:

 3     bool out(int x, int y, int m, int n) {

 4         if (x >= m || x < 0 || y >= n || y < 0) return true;

 5         return false;

 6     }

 7     void dfs(int x, int y, int dir[4][2], int dep, int m, int n, vector<int> &ret, 

 8         int direct, vector<vector<bool>> &visit, vector<vector<int>> matrix) {

 9         if (dep == m*n) return;

10         visit[x][y] = true;

11         ret.push_back(matrix[x][y]);

12         if (out(x+dir[direct][0], y+dir[direct][1], m, n) || visit[x+dir[direct][0]][y+dir[direct][1]])

13             direct = (direct+1) % 4;

14         dfs(x+dir[direct][0], y+dir[direct][1], dir, dep+1, m, n, ret, direct, visit, matrix);

15     }

16     vector<int> spiralOrder(vector<vector<int> > &matrix) {

17         // Start typing your C/C++ solution below

18         // DO NOT write int main() function

19         vector<int> ret;

20         if (!matrix.size()) return ret;

21         int m = matrix.size();

22         int n = matrix[0].size();

23         int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

24         vector<vector<bool>> visit(m, vector<bool>(n, false));

25         dfs(0, 0, dir, 0, m, n, ret, 0, visit, matrix);

26         return ret;

27     }

28 };

 后来写了个不用递归的，这个复杂度会低

 1 class Solution {

 2 public:

 3     bool check(int x, int y, int dir[4][2], int curdir, int m, int n, vector<vector<bool> > &visit) {

 4         int xx = x + dir[curdir][0];

 5         int yy = y + dir[curdir][1];

 6         if (xx >= 0 && xx < m && yy >= 0 && yy < n && !visit[xx][yy]) return true;

 7         else return false;

 8     }

 9     vector<int> spiralOrder(vector<vector<int> > &matrix) {

10         // Start typing your C/C++ solution below

11         // DO NOT write int main() function

12         vector<int> ret;

13         if (!matrix.size() || !matrix[0].size()) return ret;

14         int m = matrix.size();

15         int n = matrix[0].size();

16         vector<vector<bool> > visit(m, vector<bool>(n));

17         int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

18         int dep, x, y, curdir;

19         curdir = x = y = dep = 0;

20         ret.push_back(matrix[0][0]);

21         visit[0][0] = true;

22         dep++;

23         while (dep < m*n) {

24             while (!check(x, y, dir, curdir, m, n, visit)) curdir = (curdir+1)%4;

25             x += dir[curdir][0];

26             y += dir[curdir][1];

27             visit[x][y] = true;

28             ret.push_back(matrix[x][y]);

29             dep++;

30         }

31         return ret;

32     }

33 };

 C#

 1 public class Solution {

 2     public List<int> SpiralOrder(int[,] matrix) {

 3         List<int> ans = new List<int>();

 4         int m = matrix.GetLength(0);

 5         int n = matrix.GetLength(1);

 6         if (m == 0 || n == 0) return ans;

 7         bool[,] visit = new bool[m, n];

 8         int[,] dir = new int[4, 2] {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

 9         int dep = 0, x = 0, y = 0, curdir = 0;

10         ans.Add(matrix[0, 0]);

11         visit[0, 0] = true;

12         dep++;

13         while (dep < m * n) {

14             while (!check(x, y, dir, curdir, m, n, visit)) curdir = (curdir + 1) % 4;

15             x += dir[curdir, 0];

16             y += dir[curdir, 1];

17             visit[x, y] = true;

18             ans.Add(matrix[x, y]);

19             dep++;

20         }

21         return ans;

22     }

23     public bool check(int x, int y, int[,] dir, int curdir, int m, int n, bool[,] visit) {

24         int xx = x + dir[curdir, 0];

25         int yy = y + dir[curdir, 1];

26         if (xx >= 0 && xx < m && yy >= 0 && yy < n && !visit[xx, yy]) return true;

27         else return false;

28     }

29 }

View Code