用LeetCode复习Java基本语法（题号1162）

Hello Java.

题目描述：
你现在手里有一份大小为NxN的地图（网格）grid，上面的每个区域（单元格）都用0和1标记好了。其中0代表海洋，1代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。
我们这里说的距离是曼哈顿距离（Manhattan Distance）：(x0, y0)和(x1, y1)这两个区域之间的距离是|x0 - x1| + |y0 - y1|。
如果我们的地图上只有陆地或者海洋，请返回-1。

示例：
输入：[[1,0,1],[0,0,0],[1,0,1]]
输出：2

输入：[[1,0,0],[0,0,0],[0,0,0]]
输出：4

提示：
1 <= grid.length == grid[0].length <= 100
grid[i][j]不是0就是1

题目链接：
https://leetcode-cn.com/problems/as-far-from-land-as-possible/

BFS代码：

class Solution {
    public int maxDistance(int[][] grid) {
    	/* 声明并初始化变量 */
        int row = grid.length;
        int col = grid[0].length;
        /* 队列存储点值 */
        Queue<int[]> queue = new LinkedList<>();
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {
                if(grid[i][j] == 1) {
                    queue.offer(new int[]{i, j});
                }
            }
        }
        if(queue.isEmpty() || queue.size() == row * col) return -1;
        /* 四个方向 */
        int[][] next = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
        int dis = -1;
        /* 队列判断:将当前队列中点向外延一位的点加入队列直到队列为空 */
        while(!queue.isEmpty()) {
            int cnt = queue.size();
            for(int i = 0; i < cnt; i++) {
                int[] cur = queue.poll();
                for(int[] item : next) {
                    int ix = cur[0] - item[0];
                    int iy = cur[1] - item[1];
                    if(ix >= 0 && ix < row && iy >= 0 && iy < col && grid[ix][iy] == 0) {
                        grid[ix][iy] = 1;
                        queue.offer(new int[]{ix, iy});
                    }
                }
            }
            /* 队列中内容遍历一遍时长度加一 */
            dis++;
        }
        return dis;
    }
}

动态规划代码：

class Solution {
    public int maxDistance(int[][] grid) {
        int row = grid.length;
        int col = grid[0].length;
        int dis = 0;
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {
                if(grid[i][j] == 1) {
                	/* 将陆地变为0 */
                    grid[i][j] = 0;
                }
                else {
                	/* 将海洋变为最大值 */
                    grid[i][j] = row + col;
                }
                /* 海洋 */
                if(grid[i][j] != 0) {
                	/* 上方:判断是否延伸值小于自身 */
                    if(i - 1 >= 0 && grid[i - 1][j] + 1 < grid[i][j]) {
                        grid[i][j] = grid[i - 1][j] + 1;
                    }
                    /* 左方:判断是否延伸值小于自身 */
                    if(j - 1 >= 0 && grid[i][j - 1] + 1 < grid[i][j]) {
                        grid[i][j] = grid[i][j - 1] + 1;
                    }
                }
            }
        }
        for(int i = row - 1; i >= 0; i--) {
            for(int j = col - 1; j >= 0; j--) {
            	/* 右方:判断是否延伸值小于自身 */
                if(i + 1 < row && grid[i + 1][j] + 1 < grid[i][j]) {
                    grid[i][j] = grid[i + 1][j] + 1;
                }
                /* 下方:判断是否延伸值小于自身 */
                if(j + 1 < col && grid[i][j + 1] + 1 < grid[i][j]) {
                    grid[i][j] = grid[i][j + 1] + 1;
                }
            }
        }
        /* 保存最大值 */
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {
                dis = (grid[i][j] > dis) ? grid[i][j] : dis;
            }
        }
        if(dis == 0 || dis == row + col) {
            return -1;
        }
        else {
            return dis;
        }
    }
}

Java中的队列

• 队列是一个先入先出的数据结构
• LinkedList类实现了Queue接口，因此可以当成队列使用
• 常用方法：offer（添加元素），poll（返回第一个元素并从队列中删除），peek（返回第一个元素），isEmpty，size等
• 参考资料：Java队列详细分析
• 参考资料：Java队列用法总结
• 参考资料：Java队列实现（顺序队列，链式队列，循环队列）

关于BFS的一点小总结

• BFS是广度优先搜索，他的兄弟是DFS深度优先搜索
• 在找极值的问题中，经常见到BFS的身影，通常借助队列来实现
• 大致模板为：初值加入队列，while循环队列非空，将队列中值取出进行操作，并将该值延伸一个单位达到的值加入队列，直到处理完毕

关于动态规划的一点小总结

• 动态规划的演进思路：暴力解法，自顶向下，备忘录式自顶向下，自底向上
• 学习探索中

待续ヾ(=･ω･=)o