feat: add solutions to lc problem: No.2127

No.2127.Maximum Employees to Be Invited to a Meeting

Author: yanglbme

solution/2100-2199/2127.Maximum Employees to Be Invited to a Meeting/README.md

@@ -68,22 +68,258 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：图的最大环 + 最长链**
+
+问题等价于求有向图的最大环，以及所有长度为 $2$ 的环加上其最长链。求这两者的较大值。
+
+求最长链到长度为 $2$ 的环，可以用拓扑排序。
+
+时间复杂度 $O(n)$。
+
+类似题目：[2360. 图中的最长环](/solution/2300-2399/2360.Longest%20Cycle%20in%20a%20Graph/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maximumInvitations(self, favorite: List[int]) -> int:
+        def max_cycle(fa):
+            n = len(fa)
+            vis = [False] * n
+            ans = 0
+            for i in range(n):
+                if vis[i]:
+                    continue
+                cycle = []
+                j = i
+                while not vis[j]:
+                    cycle.append(j)
+                    vis[j] = True
+                    j = fa[j]
+                for k, v in enumerate(cycle):
+                    if v == j:
+                        ans = max(ans, len(cycle) - k)
+                        break
+            return ans
+
+        def topological_sort(fa):
+            n = len(fa)
+            indeg = [0] * n
+            dist = [1] * n
+            for v in fa:
+                indeg[v] += 1
+            q = deque([i for i, v in enumerate(indeg) if v == 0])
+            while q:
+                i = q.popleft()
+                dist[fa[i]] = max(dist[fa[i]], dist[i] + 1)
+                indeg[fa[i]] -= 1
+                if indeg[fa[i]] == 0:
+                    q.append(fa[i])
+            return sum(dist[i] for i, v in enumerate(fa) if i == fa[fa[i]])
+
+        return max(max_cycle(favorite), topological_sort(favorite))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int maximumInvitations(int[] favorite) {
+        return Math.max(maxCycle(favorite), topologicalSort(favorite));
+    }
+
+    private int maxCycle(int[] fa) {
+        int n = fa.length;
+        boolean[] vis = new boolean[n];
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            if (vis[i]) {
+                continue;
+            }
+            List<Integer> cycle = new ArrayList<>();
+            int j = i;
+            while (!vis[j]) {
+                cycle.add(j);
+                vis[j] = true;
+                j = fa[j];
+            }
+            for (int k = 0; k < cycle.size(); ++k) {
+                if (cycle.get(k) == j) {
+                    ans = Math.max(ans, cycle.size() - k);
+                }
+            }
+        }
+        return ans;
+    }
+
+    private int topologicalSort(int[] fa) {
+        int n = fa.length;
+        int[] indeg = new int[n];
+        int[] dist = new int[n];
+        Arrays.fill(dist, 1);
+        for(int v : fa) {
+            indeg[v]++;
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            if (indeg[i] == 0) {
+                q.offer(i);
+            }
+        }
+        int ans = 0;
+        while (!q.isEmpty()) {
+            int i = q.pollFirst();
+            dist[fa[i]] = Math.max(dist[fa[i]], dist[i] + 1);
+            if (--indeg[fa[i]] == 0) {
+                q.offer(fa[i]);
+            }
+        }
+        for (int i = 0; i < n; ++i) {
+            if (i == fa[fa[i]]) {
+                ans += dist[i];
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maximumInvitations(vector<int>& favorite) {
+        return max(maxCycle(favorite), topologicalSort(favorite));
+    }
+
+    int maxCycle(vector<int>& fa) {
+        int n = fa.size();
+        vector<bool> vis(n);
+        int ans = 0;
+        for (int i = 0; i < n; ++i)
+        {
+            if (vis[i]) continue;
+            vector<int> cycle;
+            int j = i;
+            while (!vis[j])
+            {
+                cycle.push_back(j);
+                vis[j] = true;
+                j = fa[j];
+            }
+            for (int k = 0; k < cycle.size(); ++k)
+            {
+                if (cycle[k] == j)
+                {
+                    ans = max(ans, (int) cycle.size() - k);
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+
+    int topologicalSort(vector<int>& fa) {
+        int n = fa.size();
+        vector<int> indeg(n);
+        vector<int> dist(n, 1);
+        for (int v : fa) ++indeg[v];
+        queue<int> q;
+        for (int i = 0; i < n; ++i) if (indeg[i] == 0) q.push(i);
+        while (!q.empty())
+        {
+            int i = q.front();
+            q.pop();
+            dist[fa[i]] = max(dist[fa[i]], dist[i] + 1);
+            if (--indeg[fa[i]] == 0) q.push(fa[i]);
+        }
+        int ans = 0;
+        for (int i = 0; i < n; ++i) if (i == fa[fa[i]]) ans += dist[i];
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumInvitations(favorite []int) int {
+	a, b := maxCycle(favorite), topologicalSort(favorite)
+	return max(a, b)
+}
+
+func maxCycle(fa []int) int {
+	n := len(fa)
+	vis := make([]bool, n)
+	ans := 0
+	for i := range fa {
+		if vis[i] {
+			continue
+		}
+		j := i
+		cycle := []int{}
+		for !vis[j] {
+			cycle = append(cycle, j)
+			vis[j] = true
+			j = fa[j]
+		}
+		for k, v := range cycle {
+			if v == j {
+				ans = max(ans, len(cycle)-k)
+				break
+			}
+		}
+	}
+	return ans
+}
+
+func topologicalSort(fa []int) int {
+	n := len(fa)
+	indeg := make([]int, n)
+	dist := make([]int, n)
+	for i := range fa {
+		dist[i] = 1
+	}
+	for _, v := range fa {
+		indeg[v]++
+	}
+	q := []int{}
+	for i, v := range indeg {
+		if v == 0 {
+			q = append(q, i)
+		}
+	}
+	for len(q) > 0 {
+		i := q[0]
+		q = q[1:]
+		dist[fa[i]] = max(dist[fa[i]], dist[i]+1)
+		indeg[fa[i]]--
+		if indeg[fa[i]] == 0 {
+			q = append(q, fa[i])
+		}
+	}
+	ans := 0
+	for i := range fa {
+		if i == fa[fa[i]] {
+			ans += dist[i]
+		}
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **TypeScript**