Leetcode 54. 螺旋矩阵

题目

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例 2:

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

解答

解法一：轮圈遍历

每次遍历都转一圈，每一行或列遍历完后就更新边界值并判断是否结束。

遍历顺序：左到右，上到下，右到左，下到上。

代码

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length == 0) return new ArrayList<>();
        
        List<Integer> res = new ArrayList<>();
        int m = matrix.length;
        int n = matrix[0].length;
        
        int u = 0, d = m - 1, l = 0, r = n - 1;
        for(;;) {
            for(int i = l; i <= r; i ++) res.add(matrix[u][i]);
            if(++ u > d) break;
            
            for(int i = u; i <= d; i ++) res.add(matrix[i][r]);
            if(-- r < l) break;
            
            for(int i = r; i >= l; i --) res.add(matrix[d][i]);
            if(-- d < u) break;
            
            for(int i = d; i >= u; i --) res.add(matrix[i][l]);
            if(++ l > r) break;
        }
        
        return res;
    }
}

结果

解法二：回溯法

写完解法一之后，我自己想了想，发现也可以使用回溯法解决呀。
按照 右 -> 下 -> 左 ->上 的方向去递归不就好了吗。
但是需要注意的就是最左边的一列也就是 下 -> 上 的方向需要改变遍历顺序。
是个新思路，有兴趣的可以看看，两个解法效率差不多。

代码

class Solution {
    // (上) 右 下 左 上
    int[][] d = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    boolean[][] used;
    
    public List<Integer> spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length == 0) return new ArrayList<>();
        int row = matrix.length;
        int col = matrix[0].length;
        used = new boolean[row][col];
        List<Integer> res = new ArrayList<>();
        find(matrix, 0, 0, res);
        return res;
    }
    
    private void find(int[][] matrix, int x, int y, List<Integer> res) {
        used[x][y] = true;
        res.add(matrix[x][y]);
        
        int startIdx = 1;
        // 向左 和 向下 都不能使用的话，说明是最左边的那一列，优先搜索 上 即可
        if(!canUse(matrix, x, y - 1) && !canUse(matrix, x + 1, y)) startIdx = 0;
        for(int i = startIdx; i < d.length; i ++) {
            int newX = x + d[i][0];
            int newY = y + d[i][1];
            if(canUse(matrix, newX, newY)) {
                find(matrix, newX, newY, res);
            }
        }
    }
    
    private boolean canUse(int[][] matrix, int x, int y) {
        return x >= 0 && x < matrix.length && y >= 0 && y < matrix[0].length && !used[x][y];
    }

}

结果