Java 算法题笔记（二，二维数组）

力扣刷到的一题，做一下笔记。

 思路先找出格子里所有腐烂的橘子，然后这些橘子每传染一次，记深度+1 ，直到不能再传染了为止，再去判断这些橘子里，是否还有好橘子，如果有则为不能完全传染，返回-1 ，如果没有则为能全部传完，那就返回深度值。

 // 原来，dr，dc 是控制上下左右移动的，这里写的是上，左，下，右
    public static int orangesRotting(int[][] grid){
        int[] dr = new int[]{-1,0,1,0}; // 行，控制竖着移动
        int[] dc = new int[]{0,-1,0,1};

        int R = grid.length,C = grid[0].length;
        Queue<Integer> queue = new ArrayDeque<>();
        Map<Integer,Integer> depth = new HashMap<>();
        for (int r=0; r<R; ++r){
            for (int c=0; c<C; c++){
                // 记录腐烂的橘子位置
                if (grid[r][c] == 2){
                    int code = r * C + c; // 计算坏橘子关于行列的标号
                    queue.add(code);
                    depth.put(code,0);
                }
            }
        }

        int ans = 0;
        while (!queue.isEmpty()){
            int code = queue.remove(); // 去第一个
            int r = code/C; // 几个满行
            int c = code%C; // 在第几列，余出几个单
            for (int k=0; k<4; ++k){
                // 计算移位后的新坐标
                int nr = r + dr[k];
                int nc = c + dc[k];
                // 先判断有没有越界，再判断有没有好橘子
                if (0 <= nr && nr <R && 0 <= nc && nc < C &&
                        grid[nr][nc] == 1){
                    grid[nr][nc] = 2; // 好橘子被传染，赋值为2
                    int ncode = nr * C + nc; // 计算新坏橘子关于行列的标号
                    queue.add(ncode); // 存入队列，因为该橘子还可能传染新橘子
                    // 深度加一，并记录
                    // 注意这里之所以用map 是因为，这里不是ans+1 就行的，
                    // 一个code 的四周算一个深度，所以只加一次1 就行了，
                    // 所以不是ans 逐步+1 ，而是每次都这针对之前存的到map 里的code 的值+1
                    depth.put(ncode,depth.get(code)+1);
                    ans = depth.get(ncode);
                }
            }
        }

        // 当队列里的坏橘子，全移除，说明，没有可传染的情况
        // 那么检查一下还有没有好橘子存在，如果有，说明不可全部传染到，返回-1
        for (int[] row : grid){ // 取出某一行的移位数组
            for (int v : row){ // 取出某一行，某一列的值
                if (v == 1) return -1; // 在这用的二维数组的遍历
            }
        }

        // 没有经传染过程后，没有好橘子存在，那么返回传染的最大深度
        return ans;
    }

顺时针打印二位数组

 通过这个题可以知道二位数组的移动可以通过横纵坐标的加一或减一实现，比较有规律的情况，可以通过定义数组来算实现。

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

public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> ans = new ArrayList<>();
        if (matrix.length == 0) return ans;
        int R = matrix.length, C = matrix[0].length;
        boolean[][] seen = new boolean[R][C];
        int[] dr = {0, 1, 0, -1};
        int[] dc = {1, 0, -1, 0};
        // 0  ，1  行不变右移（列加一）
        // 1  ，0  列不变下移（行加一）
        // 0  ，-1 行不变左移（列减一）
        // -1 ，0  列不变上移（行减一）
        // 这样的两个数组来到达顺时针移动
        int r = 0, c = 0, di = 0;
        for (int i = 0; i < R * C; i++) {
            ans.add(matrix[r][c]);
            seen[r][c] = true;
            int rTemp = r + dr[di];
            int cTemp = c + dc[di];
            if (0 <= rTemp && rTemp < R &&
                    0 <= cTemp && cTemp < C &&
                    !seen[rTemp][cTemp]) {
                r = rTemp;
                c = cTemp;
            } else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
    }