[array] leetcode - 54. Spiral Matrix - Medium

leetcode-54. Spiral Matrix – Medium

descrition

GGiven a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

For example,
Given the following matrix:

[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
You should return [1,2,3,6,9,8,7,4,5].

解析

基本思路是按照规则一个个的取数,两份方法的区别在于处理的技巧不同。

方法 1:

小技巧(si,sj),(ei, ej),对角线可以唯一确定一个矩阵。循环获取结果,每次循环获取当前最外层的一圈数字。

  1. 从左到右,matrix[si][sj,…,ej]
  2. 从上到下,matrix[si,…,ej][ej]
  3. 从右到左,matrix[ei][ej-1,…,sj]
  4. 从下到上,matrix[ei-1,…,si-1][sj]

实现如代码所示,注意边界条件。

方法 2:

我们只需要模拟时钟的顺时针行走,每走一步获取一个元素,假设矩阵 matrix 有 m 行 n 列,那么只需要循环 m * n 次即可获取所有元素。算法描述如下:

定义两个辅助数组变量如下,dr 和 dc 分别表示行和列的方向变化。

dr={0, 1, 0, -1}
dc={1, 0, -1, 0}  

两个数组共同组合有以下 4 种情况:

  1. dr[0], dc[0]:行的增量为 0,列的增量为 1,对应方法 1 的情况 1
  2. dr[1], dc[1]:行的增量为 1,列的增量为 0,对应方法 1 的情况 2
  3. dr[2], dc[2]:行的增量为 0,列的增量为 -1, 对应方法 1 的情况 3
  4. dr[3], dc[3]:行的增量为 -1,列的增量为 0,对应方法 1 的情况 4

我们总共遍历 m * n 次,每次获取一个元素,而没个元素的状态都将是以上 4 种状态中的一种。令 r,c 分别表示当前的行和列的下标,cr, cc 分别表示 candidate,即下一个候选位置的下标,di 表示当前的方向(对应以上 4 种情况,即 dr,dc 的下标),visited[][] 对应 matrix,表示元素是否被访问过。

对于任意一次遍历,若 r,c 合法,即没有超出矩阵边界又没有被访问过,那么我们可以获取当前元素。否则,我们需要调换方向,即更新 di 的值,具体实现参考代码。

实际上方法 2 不是最优解,相比于方法 1, 方法 2 需要一个辅助的数组,但其思想非常值得借鉴,尤其是状态控制的 dr[] 和 dc[] ,di

leetcode-solution

code

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution{
public:
    vector<int> spiralOrder(vector<vector<int> >& matrix){

        //return spiralOrderCycle(matrix);
        return spiralOrderSimilation(matrix);

    }


    // time-O(m*n), space-O(1) exclude the space used to return info.
    vector<int> spiralOrderCycle(vector<vector<int> >& matrix){
        vector<int> ans;
        if(matrix.empty())
            return ans;

        int rows = matrix.size(), cols = matrix[0].size();
        int si = 0, sj = 0;
        int ei = rows - 1, ej = cols - 1;

        while(si <= ei && sj<=ej){
            spiralOrderOneCycle(matrix, si, sj, ei, ej, ans);
            si++;
            sj++;
            ei--;
            ej--;
        }

        return ans;
    }

    void spiralOrderOneCycle(vector<vector<int> >& matrix, 
                             int si, int sj, int ei, int ej,
                             vector<int>& ans){
        // top row
        for(int j=sj; j<=ej; j++)
            ans.push_back(matrix[si][j]);

        // right column
        for(int i=si+1; i<=ei; i++)
            ans.push_back(matrix[i][ej]);

        // down row if exist
        if(si < ei){
            for(int j=ej-1; j>=sj; j--)
                ans.push_back(matrix[ei][j]);
        }

        // left column if exist
        if(sj < ej){
            for(int i=ei-1; i>si; i--)
                ans.push_back(matrix[i][sj]);
        }
    }

    // time-O(m*n), space=O(m*n)
    vector<int> spiralOrderSimilation(vector<vector<int> > &matrix){
        vector<int> ans;
        if(matrix.empty())
            return ans;
        int rows = matrix.size(), cols = matrix[0].size();
        vector<vector<bool> > visited(rows, vector<bool>(cols, false));
        int dr[] = {0, 1, 0, -1};
        int dc[] = {1, 0, -1, 0};
        // start from the left-top corner (r,c) = (0,0) and from left to right
        // di = 0, dr[0] and dc[0], correspond left to right.
        int di = 0, r = 0, c = 0; 
        
        for(int i=0; i<rows*cols; i++){
            ans.push_back(matrix[r][c]);
            visited[r][c] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
            if(0 <= cr && cr < rows && 0 <= cc && cc < cols && !visited[cr][cc]){
                r = cr;
                c = cc; 
            }else{
                // change direction
                di = (di + 1) % 4;
                r = r + dr[di];
                c = c + dc[di];
            }
        }

        return ans;
    }
};

int main()
{
    return 0;
}

作者:fanling999 链接:https://www.cnblogs.com/fanling999/

    原文作者:fanling999
    原文地址: https://www.cnblogs.com/fanling999/p/7882056.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞