螺旋矩阵总结

对于螺旋矩阵来说，没有什么很出名的算法来特定解决这个问题，不过对于这种题的解题方法和套路也很多，这里介绍两种：

一种是以方向为主，每次根据正在进行的前进方向做讨论，然后每个方向又有遇到转角的情况，这个方法思维还是很清晰的，而且时间复杂度不会比其他的方法高，也不是很麻烦。

一种是以边界为主，即每次沿着边界前进，每一次大循环都把整个边界走一遍，每次走完一个方向的边界就把相应边界缩小，这个方法优点就是代码量少，看起来很简介，不过有一个问题，就是判断什么时候结束，因为可能存在在中间走完的情况，就有可能会多压几个数据，一个方法是每个小循环里判断的时候加一个判断，另一个就是后面再做剪切，具体看后面的题和代码吧。

第一题：59. 螺旋矩阵 II

这题我是用那种按方向来走做的，就判断现在在哪个方向，是否走到尽头。

/**
* 解题思路：首先对二维数组进行初始化，使其变为一个n*n所有初值为0的矩阵，开始循环，循环终止条件为1到n平方都被
* 放入二维数组中，每步循环分为四种情况讨论，上下左右，每个情况讨论走到边界和没有走到边界的情况，走到边界就按顺时针
* 移动，没有走到边界就继续走，最终按返回二维数组。
*/

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));
        string str = "right";
        int row = 0, col = 0;
        int t = 0, d = n - 1, l = 0, r = n - 1;
        for (int i = 1; i <= n * n; i++) {
            result[row][col] = i;
            if (str == "right") {
                if (col == r) {
                    str = "down";
                    row++;
                    t++;
                }
                else 
                    col++;
            }
            else if (str == "down") {
                if (row == d) {
                    str = "left";
                    col--;
                    r--;
                }
                else
                    row++;
            }
            else if (str == "left") {
                if (col == l) {
                    str = "up";
                    row--;
                    d--;
                }
                else
                    col--;
            }
            else if (str == "up") {
                if (row == t) {
                    str = "right";
                    col++;
                    l++;
                }
                else
                    row--;
            }
        }
        return result;
    }
};

第二题：54. 螺旋矩阵

这个题就还是那种思想做呗，沿边界走，逐渐缩小边界。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        vector<int> result;
        int top = 0, down = m - 1, left = 0, right = n - 1;
        int k = 0, i = 0;
        while (k < n * m) {
            for (i = left; i <= right; i++, k++)
                result.push_back(matrix[top][i]);
            top++;
            for (i = top; i <= down; i++, k++) 
                result.push_back(matrix[i][right]);
            right--;
            for (i = right; i >= left; i--, k++) 
                result.push_back(matrix[down][i]);
            down--;
            for (i = down; i >= top; i--, k++) 
                result.push_back(matrix[i][left]);
            left++;
        }
        auto first = result.begin();
        vector<int> ans(first, first + m*n);
        return ans;
    }
};

其实两种方法是同一个思想，还是用第二种方法吧。

其实还有一道题，不过还没做，之后再补上吧。总之我觉得这个上面这两个螺旋矩阵问题就是一直走，走到走不了再转向。

第三题：885. 螺旋矩阵 III

有一说一，这道题我还真不太会做，做的人也比较少，解法不多，不过后来我看了一个同学做的跟前两道题结合起来感觉对这个螺旋矩阵的解法认识又加深了一步，这个螺旋矩阵我觉得普适的想法是一个大循环代表转一圈（360度)，然后在转的过程中找到在每个方向要走多少步，例如前两道题通过边界判断来确定在每个方向要走多少步，最后这道题通过发现的规律来确定要走多少步。即每个大循环中有四个小循环代表每个方向行走，在走的过程中要更改一些变量来重新确定每个方向的步数。

/**
* 解题思路：这道题还是模拟，我们可以观察到要完成360度的一圈，在向右和向下这两个方向每次走奇数步（1,3,5），
* 在向左和向上的方向走偶数步（2,4,6），这样一直循环直到走完所有的节点，边走边记录，如果是矩阵外就不记录
* 最后返回结果。
*/
class Solution {
public:
    vector<vector<int>> spiralMatrixIII(int rows, int cols, int rStart, int cStart) {
        vector<vector<int>> result;
        int steps = 1;
        int allSum = rows * cols, s = 1;
        result.push_back({rStart, cStart});
        while (s < allSum) {
            for (int k = 0; k < steps; k++) {
                cStart++;
                if (rStart >=0 && cStart >= 0 && rStart < rows && cStart < cols) {
                    result.push_back({rStart, cStart});
                    s++;
                }
            }
            for (int k = 0; k < steps; k++) {
                rStart++;
                if (rStart >=0 && cStart >= 0 && rStart < rows && cStart < cols) {
                    result.push_back({rStart, cStart});
                    s++;
                }
            }
            steps++;
            for (int k = 0; k < steps; k++) {
                cStart--;
                if (rStart >=0 && cStart >= 0 && rStart < rows && cStart < cols) {
                    result.push_back({rStart, cStart});
                    s++;
                }
            }
            for (int k = 0; k < steps; k++) {
                rStart--;
                if (rStart >=0 && cStart >= 0 && rStart < rows && cStart < cols) {
                    result.push_back({rStart, cStart});
                    s++;
                }
            }
            steps++;
        }
        return result;

    }
};