参加会议的最多员工数

一个公司准备组织一场会议，邀请名单上有 n 位员工。公司准备了一张 圆形 的桌子，可以坐下 任意数目 的员工。

员工编号为 0 到 n - 1 。每位员工都有一位 喜欢 的员工，每位员工 当且仅当 他被安排在喜欢员工的旁边，他才会参加会议。每位员工喜欢的员工 不会 是他自己。

给你一个下标从 0 开始的整数数组 favorite ，其中 favorite[i] 表示第 i 位员工喜欢的员工。请你返回参加会议的 最多员工数目 。

示例 1：

输入：favorite = [2,2,1,2]
输出：3
解释：
上图展示了公司邀请员工 0，1 和 2 参加会议以及他们在圆桌上的座位。
没办法邀请所有员工参与会议，因为员工 2 没办法同时坐在 0，1 和 3 员工的旁边。
注意，公司也可以邀请员工 1，2 和 3 参加会议。
所以最多参加会议的员工数目为 3 。

示例 2：

输入：favorite = [1,2,0]
输出：3
解释：
每个员工都至少是另一个员工喜欢的员工。所以公司邀请他们所有人参加会议的前提是所有人都参加了会议。
座位安排同图 1 所示：
- 员工 0 坐在员工 2 和 1 之间。
- 员工 1 坐在员工 0 和 2 之间。
- 员工 2 坐在员工 1 和 0 之间。
参与会议的最多员工数目为 3 。

示例 3：

输入：favorite = [3,0,1,4,1]
输出：4
解释：
上图展示了公司可以邀请员工 0，1，3 和 4 参加会议以及他们在圆桌上的座位。
员工 2 无法参加，因为他喜欢的员工 0 旁边的座位已经被占领了。
所以公司只能不邀请员工 2 。
参加会议的最多员工数目为 4 。

提示：

• n == favorite.length

• 2 <= n <= 105

• 0 <= favorite[i] <= n - 1

• favorite[i] != i

class Solution {
​
    public int maximumInvitations(int[] favorite) {
        int n = favorite.length;
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        int[] in = new int[n];// 获取所有节点入度
        for (int i = 0; i < n; i++) {
            graph.get(i).add(favorite[i]);
            in[favorite[i]]++;
        }
        LinkedList<Integer> queue = new LinkedList<>();// 把入度为零的节点加入队列
        for (int i = 0; i < n; i++) {
            if (in[i] == 0) {
                queue.addLast(i);
            }
        }
        while (!queue.isEmpty()) {// 队列为空后，如果还有入度不为零的节点，他们将成环
            int cur = queue.removeFirst();
            for (int next : graph.get(cur)) {
                if (--in[next] == 0) {
                    queue.addLast(next);
                }
            }
        }
        int ans = 0;
        boolean[] visited = new boolean[n];
        HashMap<Integer, Integer> map = new HashMap<>();// 获取双向奔赴的两个节点
        for (int i = 0; i < n; i++) {
            if (in[i] == 1 && !visited[i]) {
                int cur = i;
                int cnt = 0;
                while (!visited[cur]) {
                    cnt++;
                    visited[cur] = true;
                    cur = favorite[cur];
                }
                if (cnt > 2) {
                    ans = Math.max(ans, cnt);// 如果当前环是多人首尾相连，那么答案可能在其中，取最大
                } else {
                    map.put(i, favorite[i]);// 双向奔赴
                }
            }
        }
        graph = new ArrayList<>();// 构建反图，为了获取从双向奔赴节点到最远端节点的距离
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int i = 0; i < n; i++) {
            graph.get(favorite[i]).add(i);
        }
        int best = 0;// 所有双向奔赴节点都可以参与会议
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            int i = entry.getKey();
            int j = entry.getValue();
            // 从双向奔赴节点两侧各自宽度优先遍历，获取最大深度
            queue.add(i);
            int level = 0;
            while (!queue.isEmpty()) {
                int size = queue.size();
                while (size-- > 0) {
                    int cur = queue.removeFirst();
                    for (int next : graph.get(cur)) {
                        if (next != j) {
                            queue.addLast(next);
                        }
                    }
                }
                level++;
            }
            queue.add(j);
            while (!queue.isEmpty()) {
                int size = queue.size();
                while (size-- > 0) {
                    int cur = queue.removeFirst();
                    for (int next : graph.get(cur)) {
                        if (next != i) {
                            queue.addLast(next);
                        }
                    }
                }
                level++;
            }
            best += level;
        }
        return Math.max(ans, best);// 返回（多人首尾相连最大值） 与 （双向奔赴节点集群累加和）的最大值
    }
}