Hot100-Day06-T54螺旋矩阵

Day06[26/3/6]T54.螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 10
• -100 <= matrix[i][j] <= 100

解题思路

其实很简单，可以发现就是一直在循环：1.向右走；2.向下走；3.向左走；4.向上走。

然后考虑，每走一行或者一列，你下次走相反方向的时候，走的长度就变短了！

所以你可以维护四个变量，每个记录去往上下左右四个方向时，不要走超过了。

Code

#include <iostream>
using namespace std;

#include <vector>
#include <algorithm>

class Solution
{
public:
    vector<int> spiralOrder(vector<vector<int>> &matrix)
    {
        // 存储结果
        vector<int> result;
        // 四周限制
        int left_limits = 0;
        int right_limits = matrix[0].size() - 1;
        int top_limits = 0;
        int bottom_limits = matrix.size() - 1;
        // 方向: 0右 1下 2左 3上
        int direction = 0;

        // 扫描
        while (left_limits != right_limits + 1 && top_limits != bottom_limits + 1)
        {

            switch (direction % 4)
            {
            case 0: // 右
                for (int j = left_limits; j <= right_limits; j++)
                {
                    result.push_back(matrix[top_limits][j]);
                }
                top_limits++;
                break;

            case 1: // 下
                for (int i = top_limits; i <= bottom_limits; i++)
                {
                    result.push_back(matrix[i][right_limits]);
                }
                right_limits--;
                break;

            case 2: // 左
                for (int j = right_limits; j >= left_limits; j--)
                {
                    result.push_back(matrix[bottom_limits][j]);
                }
                bottom_limits--;
                break;

            case 3: // 上
                for (int i = bottom_limits; i >= top_limits; i--)
                {
                    result.push_back(matrix[i][left_limits]);
                }
                left_limits++;
                break;
            }
            direction++;
        }

        return result;
    }
};

int main()
{

    // vector<vector<int>> matrix = {
    //     {1, 2, 3},
    //     {4, 5, 6},
    //     {7, 8, 9},
    // };

    vector<vector<int>> matrix = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    };

    Solution sol;

    cout << "result: [";
    for (auto num : sol.spiralOrder(matrix))
    {
        cout << num << ",";
    }
    cout << "]" << endl;

    return 0;
}