第十一章：图

DEMO

迪杰斯特拉算法

1、邻接矩阵

package LeetCode.test11_tu;

import java.util.Arrays;

/**
 * 邻接矩阵（迪杰斯特拉算法）
 */
public class demo1 {
    public int dij(int N, int M, int[][] res) {
        int[][] graph = new int[N + 1][N + 1];
        boolean[] vis = new boolean[N + 1];
        int[] d = new int[N + 1];

        for (int i = 0; i <= N; i++) {
            Arrays.fill(graph[i], Integer.MAX_VALUE);
        }
        for (int i = 0; i < M; i++) {
            graph[res[i][0]][res[i][1]] = res[i][2];
            graph[res[i][1]][res[i][0]] = res[i][2];
        }
        Arrays.fill(d,Integer.MAX_VALUE);
        d[1] = 0;  // 1到1的距离（起始点）

        for (int i = 1; i <= N; i++) {
            int u = -1, MIN = Integer.MAX_VALUE;
            for (int j = 1; j <= N; j++) { //使d[u]最小的还未被访问的顶点的标号
                if (!vis[j] && d[j] < MIN) {
                    u = j;
                    MIN = d[j];
                }
            }
            if (u == -1) {
                continue;
            }
            vis[u] = true;
            for (int v = 1; v <= N; v++) {
                if (!vis[v] && graph[u][v] != Integer.MAX_VALUE && graph[u][v] + d[u] < d[v]) {
                    d[v] = graph[u][v] + d[u];
                }
            }
        }
        return d[N];
    }
}

class Test_demo1 {
    public static void main(String[] args) {
        int N = 3, M = 3;  // N为路口数  M为路数  标号为1的路口是商店所在地，标号为N的路口是赛场所在地
        int[][] res = {{1, 2, 5}, {2, 3, 5}, {3, 1, 2}};
//        int N = 2, M = 1;
//        int[][] res = {{1, 2, 3}};
        demo1 s = new demo1();
        System.out.println(s.dij(N, M, res));
    }
}

2、邻接表

package LeetCode.test11_tu;

import java.util.*;

/**
 * 邻接表（迪杰斯特拉算法）
 */

class Node {
    int v;
    int dis;

    public Node(int v, int dis) {
        this.v = v;
        this.dis = dis;
    }
}

public class demo2 {
    public int dij(int N, int M, int[][] res) {
        boolean[] vis = new boolean[N + 1];
        int[] d = new int[N + 1];
        Map<Integer, List<Node>> map = new HashMap<>();

        for (int i = 1; i <= N; i++) {
            map.put(i, new ArrayList<>());
        }
        for (int i = 0; i < M; i++) {
            map.get(res[i][0]).add(new Node(res[i][1], res[i][2]));
            map.get(res[i][1]).add(new Node(res[i][0], res[i][2]));
        }
        Arrays.fill(d, Integer.MAX_VALUE);
        d[1] = 0;

        for (int i = 1; i <= N; i++) {
            int u = -1, MIN = Integer.MAX_VALUE;
            for (int j = 1; j <= N; j++) {
                if (!vis[j] && d[j] < MIN) {
                    u = j;
                    MIN = d[j];
                }
            }
            if (u == -1) {
                continue;
            }
            vis[u] = true;
            for (Node next : map.get(u)) {
                int v = next.v;
                int dis = next.dis;
                if (!vis[v] && dis + d[u] < d[v]) {
                    d[v] = dis + d[u];
                }
            }
        }
        return d[N];
    }
}

class Test_demo2 {
    public static void main(String[] args) {
//        int N = 3, M = 3;  // N为路口数  M为路数
//        int[][] res = {{1, 2, 5}, {2, 3, 5}, {3, 1, 2}};
        int N = 2, M = 1;
        int[][] res = {{1, 2, 3}};
        demo2 s = new demo2();
        System.out.println(s.dij(N, M, res));
    }
}

弗洛伊德算法

package LeetCode.test11_tu;

import java.util.Arrays;

/**
 * 邻接矩阵（弗洛伊德算法）
 */
public class demo3 {
    public int floyd(int N, int M, int[][] res) {
        int[][] graph = new int[N + 1][N + 1];
        for (int i = 0; i <= N; i++) {
            Arrays.fill(graph[i], Integer.MAX_VALUE);
        }
        for (int i = 0; i < M; i++) {
            graph[res[i][0]][res[i][1]] = res[i][2];
            graph[res[i][1]][res[i][0]] = res[i][2];
        }
        for (int k = 1; k <= N; k++) {
            for (int i = 1; i <= N; i++) {
                if (graph[i][k] != Integer.MAX_VALUE) {
                    for (int j = 1; j <= N; j++) {
                        if (graph[k][j] != Integer.MAX_VALUE && graph[i][j] > graph[i][k] + graph[k][j]) {
                            graph[i][j] = graph[i][k] + graph[k][j];
                        }
                    }
                }
            }
        }
        return graph[1][N];
    }
}

class Test_demo3 {
    public static void main(String[] args) {
//        int N = 3, M = 3;  // N为路口数  M为路数
//        int[][] res = {{1, 2, 5}, {2, 3, 5}, {3, 1, 2}};
        int N = 2, M = 1;
        int[][] res = {{1, 2, 3}};
        demo3 s = new demo3();
        System.out.println(s.floyd(N, M, res));
    }
}

一、二分图

1、判断二分图

问题：

存在一个 无向图 ，图中有 n 个节点。其中每个节点都有一个介于 0 到 n - 1 之间的唯一编号。给你一个二维数组 graph ，其中 graph[u] 是一个节点数组，由节点 u 的邻接节点组成。形式上，对于 graph[u] 中的每个 v ，都存在一条位于节点 u 和节点 v 之间的无向边。该无向图同时具有以下属性：
　　不存在自环（graph[u] 不包含 u）。
　　不存在平行边（graph[u] 不包含重复值）。
　　如果 v 在 graph[u] 内，那么 u 也应该在 graph[v] 内（该图是无向图）
　　这个图可能不是连通图，也就是说两个节点 u 和 v 之间可能不存在一条连通彼此的路径。
二分图 定义：如果能将一个图的节点集合分割成两个独立的子集 A 和 B ，并使图中的每一条边的两个节点一个来自 A 集合，一个来自 B 集合，就将这个图称为 二分图 。

如果图是二分图，返回 true ；否则，返回 false 。

示例 1：

输入：graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
输出：false
解释：不能将节点分割成两个独立的子集，以使每条边都连通一个子集中的一个节点与另一个子集中的一个节点。
示例 2：

输入：graph = [[1,3],[0,2],[1,3],[0,2]]
输出：true
解释：可以将节点分成两组: {0, 2} 和 {1, 3} 。

package LeetCode.test11_tu;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 思路：对未染色的节点进行染色，并且检查是否有颜色相同的相邻节点存在。
 *      用0表示未检查的节点，用1和2表示两种不同的颜色。
 */
public class ques_785_判断二分图 {
    public boolean isBipartite(int[][] graph) {
        int length = graph.length;
        if (length == 0) {
            return true;
        }
        int[] color = new int[length];
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < length; i++) {
            if (color[i] == 0) {
                queue.offer(i);
                color[i] = 1;
            }
            while (!queue.isEmpty()) {
                Integer poll = queue.poll();
                for (Integer j : graph[poll]) {
                    if (color[j] == 0) {
                        queue.offer(j);
                        color[j] = (color[poll] == 1 ? 2 : 1);
                    } else if (color[poll] == color[j]) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

class Test_785 {
    public static void main(String[] args) {
//        int[][] graph = {{1, 2, 3}, {0, 2}, {0, 1, 3}, {0, 2}};
        int[][] graph = {{1, 3}, {0, 2}, {1, 3}, {0, 2}};
        ques_785_判断二分图 s = new ques_785_判断二分图();
        System.out.println(s.isBipartite(graph));
    }
}

二、拓扑排序

2、课程表II

问题：

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：[0,1]
解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
示例 2：

输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
输出：[0,2,1,3]
解释：总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
示例 3：

输入：numCourses = 1, prerequisites = []
输出：[0]

package LeetCode.test11_tu;

import java.util.*;

/**
 * 思路：拓扑排序最经典的算法是Kahn算法。
 * 首先，先拿出所有入度为0的点排在前面，并在原图中将它们删除；
 * 这时有些点的入度减少了，于是再拿出当前所有入度为0的点放在已经排序的序列后面，然后删除；
 * 因为是有向无环图，而且删除操作不会产生环，所以每时每刻都一定存在入度为0的点，一定可以不断进行下去，直到所有点被删除。
 */
public class ques_210_课程表II {
    List<List<Integer>> graph;  // 图
    int[] inDegree; // 度
    int[] result;
    int index;

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        graph = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            graph.add(new ArrayList<>());
        }
        inDegree = new int[numCourses];
        result = new int[numCourses];
        index = 0;

        for (int[] pre : prerequisites) {
            graph.get(pre[1]).add(pre[0]);  // [[1, 2], [3], [3], []]
            inDegree[pre[0]]++;  // [0, 1, 1, 2]
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            Integer top = queue.poll();
            result[index++] = top;
            for (Integer t : graph.get(top)) { // [1, 2]
                inDegree[t]--;
                if (inDegree[t] == 0) {
                    queue.offer(t);
                }
            }
        }
        if (index != numCourses) {
            return new int[0];
        }
        return result;
    }
}

class Test_210 {
    public static void main(String[] args) {
        int numCourses = 4;
        int[][] prerequisites = {{1, 0}, {2, 0}, {3, 1}, {3, 2}};
        ques_210_课程表II s = new ques_210_课程表II();
        System.out.println(Arrays.toString(s.findOrder(numCourses, prerequisites)));
    }
}

三、最小生成树

并查集

package LeetCode.test11_tu;

/**
 * 主题：Union-Find算法(并查集)
 * ps:https://segmentfault.com/a/1190000038593250   https://segmentfault.com/a/1190000038594253
 * 1、用parent数组记录每个节点的父节点，相当于指向父节点的指针，所以parent数组内实际存储着一个森林（若干棵多叉树）。
 * 2、用size数组记录着每棵树的重量，目的是让union后树依然拥有平衡性，而不会退化成链表，影响操作效率。
 * 3、在find函数中进行路径压缩，保证任意树的高度保持在常数，使得union和connected API时间复杂度为O(1)。
 */
public class UF {
    private int count; // 连通分量个数
    private int[] parent; //存储一棵树
    private int[] size; //记录树的重量（小一些的树接到大一些的树下面）

    public UF(int n) {
        this.count = n;
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = i;
        }
    }

    public int find(int x) {
        while (parent[x] != x) {
            parent[x] = parent[parent[x]]; // 路径压缩
            x = parent[x];
        }
        return x;
    }

    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) { //产生环
            return;
        }

        if (size[rootP] > size[rootQ]) {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        } else {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        }
        count--;
    }

    public boolean connected(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        return rootP == rootQ;
    }

    public int count(){
        return count;
    }
}

3、最低成本联通所有城市

问题：

想象一下你是个城市基建规划者，地图上有 N 座城市，它们按以 1 到 N 的次序编号。

给你一些可连接的选项 conections，其中每个选项 conections[i] = [city1, city2, cost] 表示将城市 city1 和城市 city2 连接所要的成本。（连接是双向的，也就是说城市 city1 和城市 city2 相连也同样意味着城市 city2 和城市 city1 相连）。

返回使得每对城市间都存在将它们连接在一起的连通路径（可能长度为 1 的）最小成本。该最小成本应该是所用全部连接代价的综合。如果根据已知条件无法完成该项任务，则请你返回 -1。

示例 1：

输入：N = 3, conections = [[1,2,5],[1,3,6],[2,3,1]]
输出：6
解释：
选出任意 2 条边都可以连接所有城市，我们从中选取成本最小的 2 条。
示例 2：

输入：N = 4, conections = [[1,2,3],[3,4,4]]
输出：-1
解释：
即使连通所有的边，也无法连接所有城市。

package LeetCode.test11_tu;

import java.util.Arrays;

/**
 * 本题考察最小生成树（minimum spanning tree, MST）的求法:
 * (1)Prim’s Algorithm:利用优先队列选择最小的消耗
 * (2)Kruskal’s Algorithm，排序后使用并查集。
 */
public class ques_1135_最低成本联通所有城市 {
    public int minimumCost(int N, int[][] connections) {
        // -------------第一种方法-----------
        int[][] graph = new int[N + 1][N + 1];
        boolean[] vis = new boolean[N + 1];
        int[] d = new int[N + 1];

        for (int[] conn : connections) {
            graph[conn[0]][conn[1]] = conn[2];
            graph[conn[1]][conn[0]] = conn[2];
        }
        for (int i = 1; i <= N; i++) {
            d[i] = Integer.MAX_VALUE;
        }
        d[1] = 0;
        // return prim(N, graph, vis, d);

        // -------------第二种方法-----------
        return Kruskal(N, connections);

    }

    public int Kruskal(int N, int[][] connections) {
        UF uf = new UF(N + 1);
        Arrays.sort(connections,(a,b)->(a[2]-b[2]));
        int num = 0; // 记录权重
        for (int[] edge : connections) {
            int u = edge[0];
            int v = edge[1];
            int weight = edge[2];
            if (uf.connected(u, v)) {
                continue;
            }
            num += weight;
            uf.union(u,v);
        }

        // 节点0没有被使用，所以0会额外占用一个连通分量
        return uf.count()==2?num:-1;
    }

    public int prim(int N, int[][] graph, boolean[] vis, int[] d) {
        // Prim算法解决的问题是连通无向有权图中最小生成树问题，而Dijkstra算法解决的问题是源点到目标点的最短路径问题。
        for (int i = 1; i <= N; i++) {
            int u = -1;
            int MIN = Integer.MAX_VALUE;
            for (int j = 1; j <= N; j++) {
                if (!vis[j] && d[j] < MIN) {
                    u = j;
                    MIN = d[u];
                }
            }
            if (u == -1) {
                continue;
            }
            vis[u] = true;
            for (int v = 1; v <= N; v++) {
                if (!vis[v] && graph[u][v] < d[v]) {
                    d[v] = graph[u][v];
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= N; i++) {
            ans += d[i];
        }
        return ans != 0 ? ans : -1;
    }
}


class Test_1135 {
    public static void main(String[] args) {
//        int[][] connections = {{1, 2, 5}, {1, 3, 6}, {2, 3, 1}};
//        int N = 3;

//        int[][] connections = {{1,2,3},{3,4,4}};
//        int N = 4;

//        int[][] connections = {{1, 2, 1}, {1, 3, 2}, {2, 3, 4}};
//        int N = 3;

        int[][] connections = {{1, 2, 1}, {1, 3, 4}, {1, 4, 1},
                {2, 3, 3}, {2, 4, 2}, {3, 4, 5}};
        int N = 4;

        ques_1135_最低成本联通所有城市 s = new ques_1135_最低成本联通所有城市();
        System.out.println(s.minimumCost(N, connections));
        // 6 -1 3 5
    }
}

4、冗余连接

问题：

树可以看成是一个连通且 无环 的 无向 图。

给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。

请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的边。

示例 1：

输入: edges = [[1,2], [1,3], [2,3]]
输出: [2,3]
示例 2：

输入: edges = [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]

package LeetCode.test11_tu;

import java.util.Arrays;

public class ques_684_冗余连接 {
    public int[] findRedundantConnection(int[][] edges) {
        int n = edges.length;
        UF uf = new UF(n+1);
        for (int[] edge:edges) {
            int u = edge[0];
            int v = edge[1];
            if (uf.connected(u,v)){
                return edge;
            }
            uf.union(u,v);
        }
        return new int[0];
    }
}

class Test_684 {
    public static void main(String[] args) {
        int[][] edges = {{1, 2}, {1, 3}, {2, 3}};
        ques_684_冗余连接 s = new ques_684_冗余连接();
        System.out.println(Arrays.toString(s.findRedundantConnection(edges)));
    }
}

四、图的遍历

5、从始点到终点的所有路径

问题：

给定有向图的边 edges，以及该图的始点 source 和目标终点 destination，确定从始点 source 出发的所有路径是否最终结束于目标终点 destination，即：

　　从始点 source 到目标终点 destination 存在至少一条路径
　　如果存在从始点 source 到没有出边的节点的路径，则该节点就是路径终点。
　　从始点source到目标终点 destination 可能路径数是有限数字
当从始点 source 出发的所有路径都可以到达目标终点 destination 时返回 true，否则返回 false。

示例 1：

输入：n = 3, edges = [[0,1],[0,2]], source = 0, destination = 2
输出：false
说明：节点 1 和节点 2 都可以到达，但也会卡在那里。
示例 2：

输入：n = 4, edges = [[0,1],[0,3],[1,2],[2,1]], source = 0, destination = 3
输出：false
说明：有两种可能：在节点 3 处结束，或是在节点 1 和节点 2 之间无限循环。
示例 3：

输入：n = 4, edges = [[0,1],[0,2],[1,3],[2,3]], source = 0, destination = 3
输出：true
示例 4：

输入：n = 3, edges = [[0,1],[1,1],[1,2]], source = 0, destination = 2
输出：false
说明：从始点出发的所有路径都在目标终点结束，
但存在无限多的路径，如 0-1-2，0-1-1-2，0-1-1-1-2，0-1-1-1-1-2 等。
示例 5：

输入：n = 2, edges = [[0,1],[1,1]], source = 0, destination = 1
输出：false
说明：在目标节点上存在无限的自环。

package LeetCode.test11_tu;

import java.util.ArrayList;
import java.util.List;

/**
 * 虽然使用深度优先搜索可以解决大部分的图遍历问题，但是注意判断是否陷入了环路。
 * 终点只有一个，且没有环!!!
 */
public class ques_1059_从始点到终点的所有路径 {
    public boolean leadsToDestination(int n, int[][] edges, int source, int destination) {
        boolean[] visited = new boolean[n];
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int[] edge : edges) {
            graph.get(edge[0]).add(edge[1]);

        }
        if (!graph.get(destination).isEmpty()) { //终点后面还有路径
            return false;
        }
        return dfs(graph, visited, source, destination);
    }

    public boolean dfs(List<List<Integer>> graph, boolean[] visited, int cur, int destination) {
        if (graph.get(cur).size() == 0 && cur != destination) { //到达一个终点，但不是目标点
            return false;
        }
        for (Integer next:graph.get(cur)) {  // 访问过了(有环)
            if (visited[next]){
                return false;
            }
            visited[next] = true;
            if(!dfs(graph,visited,next,destination)){
                return false;
            }
            visited[next] = false;  // 回溯
        }
        return true;
    }
}

class Test_1059 {
    public static void main(String[] args) {
//        int n = 3;
//        int[][] edges = {{0, 1}, {0, 2}};
//        int source = 0;
//        int destination = 2;

//        int n = 4;
//        int[][] edges = {{0, 1}, {0, 3}, {1, 2}, {2, 1}};
//        int source = 0;
//        int destination = 3;

        int n = 4;
        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {2, 3}};
        int source = 0;
        int destination = 3;

        ques_1059_从始点到终点的所有路径 s = new ques_1059_从始点到终点的所有路径();
        System.out.println(s.leadsToDestination(n, edges, source, destination));
        // false false true
    }
}