图算法学习

LC 200. 岛屿数量 考频：107

---

我们首先明确一下岛屿问题中的网格结构是如何定义的，以方便我们后面的讨论。

网格问题是由 m×n 个小方格组成一个网格，每个小方格与其上下左右四个方格认为是相邻的，要在这样的网格上进行某种搜索。

岛屿问题是一类典型的网格问题。每个格子中的数字可能是 0 或者 1。我们把数字为 0 的格子看成海洋格子，数字为 1 的格子看成陆地格子，这样相邻的陆地格子就连接成一个岛屿。

class Solution {
	int n, m;
    int[] dx = {-1, 0, 1, 0};
    int[] dy = {0, -1, 0, 1};
    public int numIslands(char[][] grid) {
        n = grid.length; // row
        m = grid[0].length; // col
        int res = 0;
        for (int i = 0; i < n; i ++ ) {
            for (int j = 0; j < m; j ++ ) {
                //如果是0，直接不管，如果是1，岛屿数量加1
                if (grid[i][j] == '1') {
                    res ++;
                    //并且触发连锁反应，将与该位置相邻的1全部消除(上下左右)
                    dfs(grid, i , j);
                }
            }
        }
        return res;
    }
    //将(x,y)位置所有可以组成岛屿的地方全部消除
    void dfs(char[][] grid, int x, int y) {
        //遍历到0终止遍历
        if (grid[x][y] == '0') {
            return;
        }
        //将当前位置消除
        grid[x][y] = '0';
        //遍历上下左右4个位置(枚举上下左右四个方向的技巧，已经总结),相当于扫雷连锁消除
        for (int i = 0; i < 4; i ++ ) {
            //这个技巧里面要再定义连个变量，不要改变x,y的值，不然会影响后面的遍历
            int a = x + dx[i];
            int b = y + dy[i];
            if (a >= 0 && a < n && b >= 0 && b < m) {
                dfs(grid, a, b);
            }
        }
    }
}

LC 695. 岛屿的最大面积 考频：34

---

这题的做法与LC200题几乎一样，只不过，这里把dfs改成了带返回值的。

    int n, m;
    int[] dx = {-1, 0, 1, 0};
    int[] dy = {0, -1, 0, 1};
    public int maxAreaOfIsland(int[][] grid) {
        n = grid.length; //row
        m = grid[0].length; //col
        int ans = 0;
        for (int i = 0; i < n; i ++ ) {
            for (int j = 0; j < m; j ++ ) {
                if (grid[i][j] == 1) {
                    ans = Math.max(ans, dfs(grid, i, j));
                }
            }
        }
        return ans;
    }
    int dfs(int[][] grid, int x, int y) {
        if (grid[x][y] == 0) {
            return 0;
        }
        int res = 0;
        res += 1;
        grid[x][y] = 0;
        for (int i = 0; i < 4; i ++) {
            int a = x + dx[i];
            int b = y + dy[i];
            if (a >=0 && a < n && b >= 0 && b < m) {
                res += dfs(grid, a, b);
            }
        }
        return res;
    }

LC 547. 省份数量（原朋友圈） 考频：10

---

这题是一个无向图，矩阵为斜对角线对称，

分析题意：本题矩阵中的值表示两个节点之间是否相连，(i,j) == (j,i)，也就是本题是一个无向连通图找连通分量个数的问题。

	//矩阵的每一列的个数或者每一行的个数都表示第几个城市（无向图）
    //n 表示城市数量
    int n ;
    //st用于标识该城市是否已经遍历过
    boolean[] st;
    public int findCircleNum(int[][] isConnected) {
        n = isConnected.length;
        st = new boolean[n];
        int ans = 0;
        for (int i = 0; i < n; i ++ ) {
            if (!st[i]) {
                ans ++;
                //将所有与该城市相连(直接或间接)的城市
                dfs(isConnected, i);
            }
        }
        return ans;
    }
    void dfs(int[][] isConnected, int i) {
        //将当前城市标识已遍历
        st[i] = true;
        for (int j = 0; j < n; j ++ ) {
            //如果城市j与城市i相连，且还未被访问过，就以j作为新节点继续递归找到与j相连的其他城市
            if (isConnected[i][j] == 1 && !st[j]) {
                dfs(isConnected, j);
            }
        }
    }

LC207. 课程表 考频：13

---

首先，这是一个有向图，这道题的本质就是判断该有向图(graph)是否存在环，如果有环，说明矛盾（死锁）。

下面这种情况就是存在死锁问题。

下面这种就不存在死锁问题。

拓扑结构：
	使用bfs
	方法一：入度表（广度优先遍历）
    算法流程：
    1. 统计课程安排图中每个节点的入度，生成 入度表 indegrees。
    2. 借助一个队列 queue，将所有入度为 0 的节点入队。
    3. 当 queue 非空时，依次将队首节点出队，在课程安排图中删除此节点 pre：
    	 3.1 并不是真正从邻接表中删除此节点 pre，而是将此节点对应所有邻接节点 cur 的入度 -1，即 indegrees[cur] -= 1。
    	 3.2 当入度 -1后邻接节点 cur 的入度为 0，说明 cur 所有的前驱节点已经被 “删除”，此时将 cur 入队。
    4. 在每次 pre 出队时，执行 numCourses--；
    	4.1 若整个课程安排图是有向无环图（即可以安排），则所有节点一定都入队并出队过，即完成拓扑排序。换个角度说，若课程安排图中存在环，一定有节点的入度始终不为 0。
    	4.2 因此，拓扑排序出队次数等于课程个数，返回 numCourses == 0 判断课程是否可以成功安排。

//统计每一门课程的入度（就是☞有多少个节点指向它）
    //bfs
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        //入度数组，统计每一个课程有多少个前置课程
        int[] indegrees = new int[numCourses];
        //记录一门课程修完之后可以修那些课程 （其实就是建立邻接表）
        List<List<Integer>> list = new ArrayList<>();
        for(int i = 0;i < numCourses;i++){
            list.add(new ArrayList<>());
        }
        for(int[] info : prerequisites){
            //记录当前课程修完之后可以修那些课程
            list.get(info[1]).add(info[0]);
            //当前课程的入度+1
            indegrees[info[0]]++;
        }
        //BFS
        Queue<Integer> q = new LinkedList<>();
        //将入度为0的全部加入队列当中
        for (int i = 0; i < numCourses; ++i) {
            if (indegrees[i] == 0) {
                q.offer(i);
            }
        }
        //visited记录已经修了多少门课程
        int visited = 0;

        while(!q.isEmpty()){
            ++ visited;
            //由于这些课程入度为0，所以肯定是先修的；
            int n = q.poll();
            for(int a : list.get(n)){
                //当前集合中的课程都是以n为前置课程，所以该集合中的课程入度均-1
                indegrees[a]--;
                //判断当前课程是否入读为0
                if(indegrees[a] == 0){
                    q.offer(a);
                }
            }
        }
        return visited == numCourses;
    }```