玖雨y的算法刷题记录day09——图论

玖雨y的算法刷题记录day09——图论

• 题目链接：冗余连接II
• 题目思路：在day08冗余连接一题的基础上，这题将无向图改为有向图，整体还是通过并查集来实现的，但相对要复杂一些，因为在处理无向图时我们仅需要考虑删除使树构成环的一条边，而在有向图中，我们可能有多条侯选边，需要从中作出选择。具体可参考：冗余连接II思路

import java.util.*;
// 情况一：如果有节点入度为2，则任意删除一条边（两个选择）
// 情况二：如果有节点入度为2，则需要挑选一条边进行删除（一个选择）
// 情况三：如果没有节点入度为2，则有环图，删掉环的一边（一个选择）
class Main {

    private static int[] father;

    private static void init() {
        for (int i = 0; i < father.length; i++) {
            father[i] = i;
        }
    }

    private static boolean isSame(int x, int y) {
        int fx = find(x);
        int fy = find(y);
        return fx == fy;
    }

    private static int find(int u) {
        if (u == father[u]) return u;
        return father[u] = find(father[u]);
    }

    private static void join(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return;
        father[u] = v;
    }
    
    private static boolean isTreeAfterRemoveEdge(List<int[]> edges, int[] removeEdge) {
        // 初始化并查集
        init();
        // 判断是否连通
        for (int[] edge : edges) {
            if (edge[0] == removeEdge[0] && edge[1] == removeEdge[1]) continue;
            if (!isSame(edge[0], edge[1])) join(edge[0], edge[1]);
            else return false;
        }
        return true;
    }
    
    private static void getRemoveEdge(List<int[]> edges) {
        // 初始化并查集
        init();
        for (int[] edge : edges) {
            if (!isSame(edge[0], edge[1])) {
                // 有环就肯定是最后一条连上的边
                join(edge[0], edge[1]);
            } else {
                System.out.println(edge[0] + " " + edge[1]);
                return;
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //  记录每条边
        List<int[]> edges = new ArrayList<>();
        // 记录每个节点的入度
        int[] inDegree = new int[n + 1];
        father = new int[n + 1];
        while (n-- != 0) {
            int s = sc.nextInt();
            int t = sc.nextInt();
            inDegree[t]++;
            edges.add(new int[]{s, t});
        }
        // 存放入度为2的边
        LinkedList<int[]> twoDegreeEdge = new LinkedList<>();
        for (int[] edge : edges) {
            if (inDegree[edge[1]] == 2) twoDegreeEdge.addFirst(edge);
        }
        if (!twoDegreeEdge.isEmpty()) {
            // 存在入度为2的节点
            // 已经倒序，所以删除第一条边
            if (isTreeAfterRemoveEdge(edges, twoDegreeEdge.get(0))) {
                // 情况一
                System.out.println(twoDegreeEdge.get(0)[0] + " " + twoDegreeEdge.get(0)[1]);
            } else {
                // 情况二，只有一种选择，只能删除另外一条边
                System.out.println(twoDegreeEdge.get(1)[0] + " " + twoDegreeEdge.get(1)[1]);
            }
            return;
        }
        // 情况三
        getRemoveEdge(edges);
    }
}