54. Spiral Matrix [Medium]

（效率最高的solution在最后一个

/**
 * 自己的代码
 * 每次都读矩阵第一行，然后构造一个新的去掉第一行、逆时针旋转的矩阵，直到矩阵元素全部被去掉
 * Runtime: 0 ms, faster than 100.00%
 * Memory Usage: 38.8 MB, less than 5.21%
 */
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList();
        while (matrix != null) {
            for (int i : matrix[0]) { // always read the first row
                res.add(i);
            }
            matrix = truncateMatrix(matrix);
        }
        return res;
    }

    private int[][] truncateMatrix(int[][] readMatrix) {
        int col = readMatrix.length - 1, row = readMatrix[0].length;
        if (col == 0) {
            return null;
        }
        int[][] newMatrix = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                newMatrix[i][j] = readMatrix[j + 1][row - 1 - i];
            }
        }
        return newMatrix;
    }
}

/**
 * dfs，很妙的解法
 * 在每个点都按右下左上的顺序进入dfs递归，一圈一圈地看：
 * 每次从左上角进入逆时针traverse border，先右到底
 * 再进入的点无法继续往右，就会往下，往下的点还是无法往右，继续往下到底
 * 在进入的点无法往右or往下，就会往左，往左的点还是无法往右or往下，继续往左到底
 * 再进入的点开启往上的遍历，但往上的点可以往右走，因此要让往上的遍历过程只能往上不能往其他方向
 * 用goingUp参数标识往上的遍历过程，如果是goingUp，先进入往上的dfs，等遍历到顶，才接着右下左上的正常遍历顺序，这便又开启了一个新的圈
 * Runtime: 0 ms, faster than 100.00%
 * Memory Usage: 38.8 MB, less than 5.21%
 */
class Solution {
    List<Integer> res;
    boolean[][] visited;
    
    public List<Integer> spiralOrder(int[][] matrix) {
        res = new ArrayList();
        visited = new boolean[matrix.length][matrix[0].length];
        dfs(0, 0, matrix, false);
        return res;
    }
    
    /**
     * @param x current col
     * @param y current row
     */
    private void dfs(int x, int y, int[][] matrix, boolean goingUp) {
        if (x < 0 || x >= matrix[0].length || y < 0 || y >= matrix.length || visited[y][x]) {
            return;
        }
        visited[y][x] = true;
        res.add(matrix[y][x]);
        if (goingUp) { // traversing the left border of the untraversed part, we should keep going up before going left
            dfs(x, y-1, matrix, true);
        }
        dfs(x+1, y, matrix, false);
        dfs(x, y+1, matrix, false);
        dfs(x-1, y, matrix, false);
        dfs(x, y-1, matrix, true);
    }
}

/**
 * 自己的代码
 * 最直观能想到的，一圈一圈遍历，代码比较繁琐，但空间复杂度低
 * 下面几个Solution只是过程中用了不同的写法
 * Runtime: 0 ms, faster than 100.00%
 * Memory Usage: 37.2 MB, less than 47.24%
 */
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList();
        int rowIdx = matrix.length - 1, colIdx = matrix[0].length - 1, time = 0; // time is the number of current circle
        while (time*2 <= Math.min(rowIdx, colIdx)) {
            for (int i = time; i <= colIdx - time; i++) {
                res.add(matrix[time][i]);
            }
            for (int i = time + 1; i <= rowIdx - time; i++) {
                res.add(matrix[i][colIdx - time]);
            }
            for (int i = colIdx - time - 1; i >= time && time * 2 != rowIdx; i--) {
                res.add(matrix[rowIdx - time][i]);
            }
            for (int i = rowIdx - time - 1; i > time && time * 2 != colIdx; i--) {
                res.add(matrix[i][time]);
            }
            time++;
        }
        return res;
    }
}

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList();
        int rowIdx = matrix.length - 1, colIdx = matrix[0].length - 1, time = 0; // time is the number of current circle
        while (time*2 <= Math.min(rowIdx, colIdx)) {
            for (int i = time; i <= colIdx - time; i++) {
                res.add(matrix[time][i]);
            }
            for (int i = time + 1; i <= rowIdx - time; i++) {
                res.add(matrix[i][colIdx - time]);
            }
            if (time * 2 == rowIdx) {
                return res;
            }
            for (int i = colIdx - time - 1; i >= time; i--) {
                res.add(matrix[rowIdx - time][i]);
            }
            if (time * 2 == colIdx) {
                return res;
            }
            for (int i = rowIdx - time - 1; i > time; i--) {
                res.add(matrix[i][time]);
            }
            time++;
        }
        return res;
    }
}

/**
 * 大突破：Memory Usage: 36.8 MB, less than 95.00% 
 */
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList();
        int rowIdx = matrix.length - 1, colIdx = matrix[0].length - 1, time = 0; // time is the number of current circle
        while (time*2 <= Math.min(rowIdx, colIdx)) {
            for (int i = time; i <= colIdx - time; i++) {
                res.add(matrix[time][i]);
            }
            for (int i = time + 1; i <= rowIdx - time; i++) {
                res.add(matrix[i][colIdx - time]);
            }
            if (time * 2 != rowIdx) {
                for (int i = colIdx - time - 1; i >= time; i--) {
                    res.add(matrix[rowIdx - time][i]);
                }
            }
            if (time * 2 != colIdx) {
                for (int i = rowIdx - time - 1; i > time; i--) {
                    res.add(matrix[i][time]);
                }
            }
            time++;
        }
        return res;
    }
}