Leetcode 54 - Spiral Matrix（螺旋打印矩阵）

题意

将一个矩阵螺旋打印出来。

思路

算法1

一个需要记录很多变量的思路。

首先，我们要确定走的方向是up还是down还是right还是left。

然后，确定走的方向后，我们再确定每次要走多少步，分别用rs和cs来表示。当我们在最外围的时候，rs和cs都不变，但是当我们第三次转向及以后的过程中，rs和cs每次都要-1了。

虽然变量很多但是想清楚了再写一遍能A。

算法2

直接模拟螺旋形的过程：

我们分别用u, r, d, l来表示up-most, right-most, down-most, left-most。

获得最上面的一行，然后删除最上面的一行（其实就是更新u）

获得最右边的一行，然后删除最右边的一行（其实就是更新r）

获得最下面的一行，然后删除最下边的一行（其实就是更新d）

获得最左边的一行，然后删除最左边的一行（其实就是更新l）

不停重复这个过程直到全部删除。

下面是这个过程：

代码

algorithm 1

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        if (matrix.size()) {
            int rs = matrix[0].size() - 1, cs = matrix.size() - 1;
            //control postion, r = 0: right, c = 0: down, r = 1 : left, c = 1: up
            //f, control r or c, f = 0: r; f = 1: c
            int r = 0, c = 0, f = 0, cnt = 0;
            int i = 0, j = 0;
            int m = matrix.size(), n = matrix[0].size();
            ans.push_back(matrix[i][j]);
            while (ans.size() < m * n) {
                if (!f) {
                    int rcnt = 0;
                    if (r) {
                        while (rcnt < rs) {
                            ans.push_back(matrix[i][--j]);
                            rcnt++;
                        }
                    } else {
                        while (rcnt < rs) {
                            ans.push_back(matrix[i][++j]);
                            rcnt++;
                        }
                    }
                    r ^= 1;
                    cnt++;
                    if (cnt >= 3) cs--;
                    f = 1;
                } else {
                    int ccnt = 0;
                    if (c) {
                        while (ccnt < cs) {
                            ans.push_back(matrix[--i][j]);
                            ccnt++;
                        }
                    } else {
                        while (ccnt < cs) {
                            ans.push_back(matrix[++i][j]);
                            ccnt++;
                        }
                    }
                    c ^= 1;
                    cnt++;
                    if (cnt >= 3) rs--;
                    f = 0;
                }
            }
        }
        return ans;
    }
};

algorithm 2

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        if (matrix.size()) {
            int m = matrix.size(), n = matrix[0].size();
            int u = 0, r = n - 1, d = m - 1, l = 0;
            int row = 0, col = 0;
            while (1) {
                //add the up-most row
                for (col = l; col <= r; col++) ans.push_back(matrix[u][col]);
                if (++u > d) break;
                //add the right-most col
                for (row = u; row <= d; row++) ans.push_back(matrix[row][r]);
                if (--r < l) break;
                //add the down-most row
                for (col = r; col >= l; col--) ans.push_back(matrix[d][col]);
                if (--d < u) break;
                //add the left-most col
                for (row = d; row >= u; row--) ans.push_back(matrix[row][l]);
                if (++l > r) break;
            }
        }
        return ans;
    }
};