代码随想录——图论一刷day05

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

---

一、力扣1971. 寻找图中是否存在路径

class Solution {
    int[] father;
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        father = new int[n+1];
        init();
        for(int[] edge : edges){
            join(edge[0], edge[1]);
        }
        return isSame(source, destination);
    }
    public void init(){
        for(int i = 0; i < father.length; i ++){
            father[i] = i;
        }
    }
    public int find(int u){
        // return u == father[u] ? u : father[u] = find(father[u]); 
        if(u == father[u]){
            return u;
        }else{
            father[u] = find(father[u]);
            return father[u];
        }
    }
    public boolean isSame(int u, int v){
        int uR = find(u);
        int vR = find(v);
        return uR == vR;
    }
    public void join(int u, int v){
        int uR = find(u);
        int vR = find(v);
        if(uR == vR)return;
        father[vR] = uR;
    }
}

二、力扣684. 冗余连接

class Solution {
    int[] father;
    public int[] findRedundantConnection(int[][] edges) {
        father = new int[edges.length + 1];
        int[] res = new int[2];
        init();
        for(int[] edge : edges){
            if(isSame(edge[0], edge[1])){
                res[0] = edge[0];
                res[1] = edge[1];
            }
            join(edge[0],edge[1]);
        }
        return res;
    }
    public void init(){
        for(int i = 0; i < father.length; i ++){
            father[i] = i;
        }
    }
    public int find(int u){
        if(u == father[u]){
            return u;
        }else{
            father[u] = find(father[u]);
            return father[u];
        }
    }
    public boolean isSame(int u, int v){
        int uR = find(u);
        int vR = find(v);
        return uR == vR;
    }
    public void join(int u, int v){
        int uR = find(u);
        int vR = find(v);
        if(uR == vR)return;
        father[vR] = uR;
    }
}

三、力扣685.冗余连接II

class Solution {

    private static final int N = 1010;  // 如题：二维数组大小的在3到1000范围内
    private int[] father;
    public Solution() {
        father = new int[N];

        // 并查集初始化
        for (int i = 0; i < N; ++i) {
            father[i] = i;
        }
    }

    // 并查集里寻根的过程
    private int find(int u) {
        if(u == father[u]) {
            return u;
        }
        father[u] = find(father[u]);
        return father[u];
    }

    // 将v->u 这条边加入并查集
    private void join(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return ;
        father[v] = u;
    }

    // 判断 u 和 v是否找到同一个根，本题用不上
    private Boolean same(int u, int v) {
        u = find(u);
        v = find(v);
        return u == v;
    }

    /**
     * 初始化并查集
     */
    private void initFather() {
        // 并查集初始化
        for (int i = 0; i < N; ++i) {
            father[i] = i;
        }
    }

    /**
     * 在有向图里找到删除的那条边，使其变成树
     * @param edges
     * @return 要删除的边
     */
    private int[] getRemoveEdge(int[][] edges) {
        initFather();
        for(int i = 0; i < edges.length; i++) {
            if(same(edges[i][0], edges[i][1])) { // 构成有向环了，就是要删除的边
                return edges[i];
            }
            join(edges[i][0], edges[i][1]);
        }
        return null;
    }

    /**
     * 删一条边之后判断是不是树
     * @param edges
     * @param deleteEdge 要删除的边
     * @return  true: 是树， false： 不是树
     */
    private Boolean isTreeAfterRemoveEdge(int[][] edges, int deleteEdge)
    {
        initFather();
        for(int i = 0; i < edges.length; i++)
        {
            if(i == deleteEdge) continue;
            if(same(edges[i][0], edges[i][1])) { // 构成有向环了，一定不是树
                return false;
            }
            join(edges[i][0], edges[i][1]);
        }
        return true;
    }

    public int[] findRedundantDirectedConnection(int[][] edges) {
        int[] inDegree = new int[N];
        for(int i = 0; i < edges.length; i++)
        {
            // 入度
            inDegree[ edges[i][1] ] += 1;
        }

        // 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
        ArrayList<Integer> twoDegree = new ArrayList<Integer>();
        for(int i = edges.length - 1; i >= 0; i--)
        {
            if(inDegree[edges[i][1]] == 2) {
                twoDegree.add(i);
            }
        }

        // 处理图中情况1 和 情况2
        // 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
        if(!twoDegree.isEmpty())
        {
            if(isTreeAfterRemoveEdge(edges, twoDegree.get(0))) {
                return edges[ twoDegree.get(0)];
            }
            return edges[ twoDegree.get(1)];
        }

        // 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
        return getRemoveEdge(edges);
    }
}