[LeetCode] Spiral Matrix

Given 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].

 

Hide Tags

  Array

 

思路：dfs

由于边界条件太多，直接构造新的数组，其边缘都有INT_MIN填充，方便边界判断

以向右为例，能向右就向右，不能向右则向下。。。 以此类推

class Solution {
    enum direct{RIGHT = 0, DOWN, LEFT, UP};
    vector<int> m_res;
    public:
#if 1
        void dfs(int i, int j, enum direct d, vector<vector<int> > &matrix)
        {
            if(matrix[i][j] != INT_MIN)// this juge can be deleted
            {
                //cout << i <<",\t" << j << endl;
                m_res.push_back(matrix[i][j]);
                matrix[i][j] = INT_MIN;

                if(d == RIGHT)
                {
                    if(matrix[i][j+1] != INT_MIN)
                        dfs(i, j+1, RIGHT, matrix);
                    else if(matrix[i+1][j] != INT_MIN)
                        dfs(i+1, j, DOWN, matrix);
                }
                else if(d == DOWN)
                {
                    if(matrix[i+1][j] != INT_MIN)
                        dfs(i+1, j, DOWN, matrix);
                    else if(matrix[i][j-1] != INT_MIN)
                        dfs(i, j-1, LEFT, matrix);
                }
                else if(d == LEFT)
                {
                    if(matrix[i][j-1] != INT_MIN)
                        dfs(i, j-1, LEFT, matrix);
                    else if(matrix[i-1][j] != INT_MIN)
                        dfs(i-1, j, UP, matrix);
                }
                else if(d == UP)
                {
                    if(matrix[i-1][j] != INT_MIN)
                        dfs(i-1, j, UP, matrix);
                    else if(matrix[i][j+1] != INT_MIN)
                        dfs(i, j+1, RIGHT, matrix);
                }
            }


        }
#endif
        vector<int> spiralOrder(vector<vector<int> > &matrix) {
            if(matrix.size() == 0 || matrix[0].size() == 0)
                return m_res;

            int row = matrix.size();
            int col = matrix[0].size();
            vector<vector<int> > newMat;
            vector<int>  intVec(col+2, INT_MIN);
            newMat.push_back(intVec);

            for(int i = 0; i < row; i++)
            {
                for(int j = 0; j < col; j++)
                {
                    intVec[j+1] = matrix[i][j];
                }
                newMat.push_back(intVec);
            }

            intVec.clear();
            intVec.resize(col+2, INT_MIN);
            newMat.push_back(intVec);

            //for(int i = 0; i < newMat.size(); i++)
            //    printVector(newMat[i]);

            dfs(1,1,RIGHT,newMat);

            return m_res;

        }
};

 改进：说实话，构造带有边界的数组还是有点麻烦，直接加上一些条件判断：

 

class Solution {
    enum direct{RIGHT = 0, DOWN, LEFT, UP};
    vector<int> m_res;
    public:
#if 1
        void dfs(int i, int j, enum direct d, vector<vector<int> > &matrix)
        {
            int row = matrix.size();
            int col = matrix[0].size();

            if(matrix[i][j] != INT_MIN)// this juge can be deleted
            {
                //cout << i <<",\t" << j << endl;
                m_res.push_back(matrix[i][j]);
                matrix[i][j] = INT_MIN;

                if(d == RIGHT)
                {
                    if( j <= col-2 && matrix[i][j+1] != INT_MIN)
                        dfs(i, j+1, RIGHT, matrix);
                    else if(i <= row-2 && matrix[i+1][j] != INT_MIN)
                        dfs(i+1, j, DOWN, matrix);
                }
                else if(d == DOWN)
                {
                    if(i <= row-2 && matrix[i+1][j] != INT_MIN)
                        dfs(i+1, j, DOWN, matrix);
                    else if(j >= 1 && matrix[i][j-1] != INT_MIN)
                        dfs(i, j-1, LEFT, matrix);
                }
                else if(d == LEFT)
                {
                    if(j >= 1 && matrix[i][j-1] != INT_MIN)
                        dfs(i, j-1, LEFT, matrix);
                    else if(i >= 1 && matrix[i-1][j] != INT_MIN)
                        dfs(i-1, j, UP, matrix);
                }
                else if(d == UP)
                {
                    if(i >= 1 && matrix[i-1][j] != INT_MIN)
                        dfs(i-1, j, UP, matrix);
                    else if(j <= col-1 && matrix[i][j+1] != INT_MIN)
                        dfs(i, j+1, RIGHT, matrix);
                }
            }


        }
#endif
public:

        vector<int> spiralOrder(vector<vector<int> > &matrix) {
            if(matrix.size() == 0 || matrix[0].size() == 0)
                return m_res;
                
            int row = matrix.size();
            int col = matrix[0].size();

            //for(int i = 0; i < matrix.size(); i++)
            //    printVector(matrix[i]);

            dfs(0,0,RIGHT,matrix);

            return m_res;

        }
};