ARTS Week 14

Algorithm

本周的 LeetCode 题目为 200. 岛屿数量

题目简介：给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

解题思路共有两种，分别是使用深度优先遍历（DFS）和广度优先遍历（BFS）。

广度优先遍历，就是同时去找所有相邻点是否为陆地。通过的代码如下：

class Solution {
    public int numIslands(char[][] grid) {
        int ans = 0;
        int rowLength = grid.length;
        int colLength = grid[0].length;
        for (int i = 0; i < rowLength; i++) {
            for (int j = 0; j < colLength; j++) {
                if (grid[i][j] == '1') {
                    ans += 1;
                    Queue<Integer> queue = new LinkedList<>();
                    queue.offer(i * colLength + j);
                    while (!queue.isEmpty()) {
                        int tmp = queue.poll();
                        int row = tmp / colLength;
                        int col = tmp % colLength;
                        if ((row - 1 >= 0) && (grid[row-1][col] == '1')) {
                            grid[row-1][col] = '-';
                            queue.offer((row-1) * colLength + col);
                        }
                        if ((row + 1 < rowLength) && (grid[row+1][col] == '1')) {
                            grid[row+1][col] = '-';
                            queue.offer((row+1) * colLength + col);
                        }
                        if ((col - 1 >= 0) && (grid[row][col-1] == '1')) {
                            grid[row][col-1] = '-';
                            queue.offer(row * colLength + col - 1);
                        }
                        if ((col + 1 < colLength) && (grid[row][col+1] == '1')) {
                            grid[row][col+1] = '-';
                            queue.offer(row * colLength + col + 1);
                        }
                    }
                }
            }
        }
        return ans;   
    }
}

深度优先遍历，简单地说就是沿着一个点一个方向一直深入去找，找不到再换方向和点。通过的代码如下：

class Solution {
    public int numIslands(char[][] grid) {
        int ans = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == '1') {
                    ans++;
                    dfs(i, j, grid);
                }
            }
        }
        return ans;
    }

    public void dfs(int row, int col, char[][] grid) {
        if ((row < 0) || (row >= grid.length) || (col < 0) || (col >= grid[0].length) || (grid[row][col] != '1')) {
            return ;
        }

        grid[row][col] = '-';
        dfs(row-1, col, grid);
        dfs(row+1, col, grid);
        dfs(row, col-1, grid);
        dfs(row, col+1, grid);
    }
}

Review

本周 Review 的英文文章为：如何寻求反馈？

作者首先分析了为什么寻求反馈会失败：首先，大多数人都倾向于执行社会规范并保持礼貌，除非可以匿名或消除后果；其次是人们都很忙，给出反馈对他们注意力有要求，所以他们都想默认说不。

那么如何有效地征求反馈意见？首先需要具体化，其次你需要根据和对方关系的深度调整具体的要求。具体包括：要求对你的某项工作提供具体的反馈、给他们一些选择、设计有用的“是”和“否”的问题、不要让他们陷入尴尬的境地。

很多情况下，你需要通过电子邮件来征求反馈意见，你可以这样做：首先让他们知道你正在努力改进，接着直接提出具体所需的帮助、给他们一个拒绝的理由（因为即使拒绝的回复也比没有回应有用）、最后别忘了感谢他们。

最后，征求反馈意见是很困难的。即使你有最明确的要求，也不是每个人都会给你反馈，更少有人会给你好的反馈。你总是有能力接受或拒绝对你有效或有用的反馈。接受对你有帮助的东西，剩下的就不要了。

Tip

Java 中自定义排序顺序。例如 Java 中的 Arrays.sort() 默认是从小到大进行排序，那如何实现从大到小的排序呢？需要注意以下两点：

1. 类型需要使用类类型，而不是原生类型。如使用 Integer 而非 int
2. 在 Arrays.sort() 中实现 Comparator 接口，重写 compare 函数来定义排序规则，compare 函数返回 -1 表示 o1 < o2，返回 0 表示 o1 == o2，返回 1 表示 o2 > o1。

示例代码如下：

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {1,2,3,4,5,6};
        // arr = [6,5,4,3,2,1]
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
    }
}

Share

本周分享一个网站，可以把 Linux 中具体条件命令的 man 手册中的内容下载为 PDF 格式，非常的好用，快来试试吧，网址为：https://manualsrepo.com/brands/linux/commands