DFS和BFS的模板

水域大小

这里图也是有含义的，每次搜索的是该点的周围8个。（节点有i * j个）

class Solution {
    private int[][] dirs = new int[][]{{1, 1}, {1, -1}, {1, 0}, {-1, 0}, {-1, -1}, {-1, 1}, {0, 1}, {0, -1}};
    public int[] pondSizes(int[][] land) {
        int m = land.length;
        int n = land[0].length;
        List<Integer> list = new ArrayList<>();
        boolean[][] mark = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (land[i][j] == 0 && !mark[i][j]) {
                    list.add(bfs(land, mark, i, j));
                }
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }

    private int bfs(int[][] land, boolean[][]mark, int i, int j) {
        Queue<Integer> queue = new LinkedList<>();
        int n = land[0].length, res = 0;
        queue.offer(n * i + j); 
        mark[i][j] = true;
        while (!queue.isEmpty()) {
            int temp = queue.poll();
            res += 1;
            for (int[] dir : dirs) {
                i = dir[0] + temp / n;
                j = dir[1] + temp % n;
                if (i >= 0 && i < land.length && j >= 0 && j < land[0].length)
                {
                    if (!mark[i][j] && land[i][j] == 0) {
                        mark[i][j] = true;
                        queue.offer(i * n + j);
                    }
                }
            }
        }
        return res;
    }
}

 

class Solution {
    private int[][] dirs = new int[][]{{1, 1}, {1, -1}, {1, 0}, {-1, 0}, {-1, -1}, {-1, 1}, {0, 1}, {0, -1}};
    public int[] pondSizes(int[][] land) {
        int m = land.length;
        int n = land[0].length;
        List<Integer> list = new ArrayList<>();
        boolean[][] mark = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (land[i][j] == 0 && !mark[i][j]) {
                    int sum = dfs(land, mark, i, j);
                    list.add(sum);
                }
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        Arrays.sort(res);
        return res;
    }

    private int dfs(int[][] land, boolean[][] mark, int i, int j) {
        if (i < 0 || i >= mark.length || j < 0 || j >= mark[0].length) return 0;
        if (land[i][j] != 0 || mark[i][j]) return 0;

        mark[i][j] = true;
        int res = 1;
        for (int[] dir : dirs) {
            res += dfs(land, mark, i+dir[0], j + dir[1]);
        }
        return res;
    }
    /*
    private int dfs(int[][] land, boolean[][] mark, int i, int j) {
        if (i < 0 || i >= mark.length || j < 0 || j >= mark[0].length) return 0;
        if (land[i][j] != 0 || mark[i][j]) return 0;

        mark[i][j] = true;
        return dfs(land, mark, i + 1, j) + dfs(land, mark, i - 1, j) + dfs(land, mark, i, j + 1) +
        dfs(land, mark, i, j - 1) + dfs(land, mark, i - 1, j + 1) + dfs(land, mark, i + 1, j - 1) +
        dfs(land, mark, i - 1, j - 1) + dfs(land, mark, i + 1, j + 1) + 1;
    }
    */
}

 

省份数量

这里图仅表示连接，每次搜索都是遍历所有未访问的节点。（节点有 i 个）

class Solution {

    public int findCircleNum(int[][] isConnected) {
        int n = isConnected.length;
        int res = 0;
        boolean[] mark = new boolean[n];
        for (int i = 0; i < n; i++) {
           if (!mark[i]) {
               res++;
               dfs(isConnected, mark, i);
           }
        } 
        return res;
    }

    private void dfs(int[][] isConnected, boolean[] mark, int i) {
        mark[i] = true;
        for (int j = 0; j < isConnected.length; j++) {
            if (isConnected[i][j] == 1 && !mark[j]) {
                dfs(isConnected, mark, j);
            } 
        }
        return;
    }
}

 

class Solution {

    public int findCircleNum(int[][] isConnected) {
        int n = isConnected.length;
        int res = 0;
        boolean[] mark = new boolean[n];
        for (int i = 0; i < n; i++) {
           if (!mark[i]) {
               res++;
               bfs(isConnected, mark, i);
           }
        } 
        return res;
    }

    private void bfs(int[][] isConnected, boolean[] mark, int i) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(i);
        mark[i] = true;
        while (!queue.isEmpty()) {
            i = queue.poll();
            mark[i] = true;
            for (int j = 0; j < isConnected.length; j++) {
                if (isConnected[i][j] == 1 && !mark[j]) {
                    mark[j] = true;
                    queue.offer(j);
                }
            }
        }
        return;
    }
}