feat: add solutions to lc problem: No.2127 (doocs#1910)

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

@@ -70,11 +70,19 @@
 
 **方法一：图的最大环 + 最长链**
 
-问题等价于求有向图的最大环，以及所有长度为 $2$ 的环加上其最长链。求这两者的较大值。
+我们观察发现，题目中员工的喜好关系可以看作一个有向图，这个有向图可以分成多个“基环内向树”的结构。在每个结构中，包含一个环，而环上的每个节点都连接着一棵树。
 
-求最长链到长度为 $2$ 的环，可以用拓扑排序。
+什么是“基环内向树”？首先，基环树是一个具有 $n$ 个节点 $n$ 条边的有向图，而内向树是指这个有向图中，每个节点都有且仅有一条出边。本题中，每个员工都有且仅有一个喜欢的员工，因此，构成的有向图可以由多个“基环内向树”构成。
 
-时间复杂度 $O(n)$。
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2100-2199/2127.Maximum%20Employees%20to%20Be%20Invited%20to%20a%20Meeting/images/05Dxh9.png"></p>
+
+对于本题，我们可以求出图的最大环的长度，这里我们只需要求出最大的一个环的长度，这是因为，如果有多个环，那么不同环之间是不连通的，不符合题意。
+
+另外，对于环的大小等于 $2$ 的长度，即存在两个员工互相喜欢，那么我们可以把这两个员工安排在一起，如果这两个员工各自被别的员工喜欢，那么我们只需要把喜欢他们的员工安排在他们的旁边即可。如果有多个这样的情况，我们可以把他们都安排上。
+
+因此，问题实际上等价于求出图的最大环的长度，以及所有长度为 $2$ 的环加上其最长链。求这两者的最大值即可。求最长链到长度为 $2$ 的环，我们可以使用拓扑排序。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `favorite` 的长度。
 
 相似题目：[2360. 图中的最长环](/solution/2300-2399/2360.Longest%20Cycle%20in%20a%20Graph/README.md)
 
@@ -87,7 +95,7 @@
 ```python
 class Solution:
     def maximumInvitations(self, favorite: List[int]) -> int:
-        def max_cycle(fa):
+        def max_cycle(fa: List[int]) -> int:
             n = len(fa)
             vis = [False] * n
             ans = 0
@@ -106,13 +114,13 @@ class Solution:
                         break
             return ans
 
-        def topological_sort(fa):
+        def topological_sort(fa: List[int]) -> int:
             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])
+            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)
@@ -314,10 +322,62 @@ func topologicalSort(fa []int) int {
 
 ### **TypeScript**
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
-
 ```ts
+function maximumInvitations(favorite: number[]): number {
+    return Math.max(maxCycle(favorite), topologicalSort(favorite));
+}
+
+function maxCycle(fa: number[]): number {
+    const n = fa.length;
+    const vis: boolean[] = Array(n).fill(false);
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (vis[i]) {
+            continue;
+        }
+        const cycle: number[] = [];
+        let j = i;
+        for (; !vis[j]; j = fa[j]) {
+            cycle.push(j);
+            vis[j] = true;
+        }
+        for (let k = 0; k < cycle.length; ++k) {
+            if (cycle[k] === j) {
+                ans = Math.max(ans, cycle.length - k);
+            }
+        }
+    }
+    return ans;
+}
 
+function topologicalSort(fa: number[]): number {
+    const n = fa.length;
+    const indeg: number[] = Array(n).fill(0);
+    const dist: number[] = Array(n).fill(1);
+    for (const v of fa) {
+        ++indeg[v];
+    }
+    const q: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (indeg[i] === 0) {
+            q.push(i);
+        }
+    }
+    let ans = 0;
+    while (q.length) {
+        const i = q.pop()!;
+        dist[fa[i]] = Math.max(dist[fa[i]], dist[i] + 1);
+        if (--indeg[fa[i]] === 0) {
+            q.push(fa[i]);
+        }
+    }
+    for (let i = 0; i < n; ++i) {
+        if (i === fa[fa[i]]) {
+            ans += dist[i];
+        }
+    }
+    return ans;
+}
 ```
 
 ### **...**

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

@@ -61,14 +61,30 @@ The maximum number of employees that can be invited to the meeting is 4.
 
 ## Solutions
 
+**Solution 1: Maximum Cycle in Graph + Longest Chain**
+
+We observe that the employee's preference relationship in the problem can be regarded as a directed graph, which can be divided into multiple "base cycle inward trees". Each structure contains a cycle, and each node on the cycle is connected to a tree.
+
+What is a "base cycle inward tree"? First, a base cycle tree is a directed graph with $n$ nodes and $n$ edges, and an inward tree means that in this directed graph, each node has exactly one outgoing edge. In this problem, each employee has exactly one favorite employee, so the constructed directed graph can be composed of multiple "base cycle inward trees".
+
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2100-2199/2127.Maximum%20Employees%20to%20Be%20Invited%20to%20a%20Meeting/images/05Dxh9.png"></p>
+
+For this problem, we can find the length of the maximum cycle in the graph. Here we only need to find the length of the largest cycle, because if there are multiple cycles, they are not connected to each other, which does not meet the problem requirements.
+
+In addition, for the size of the cycle equal to $2$, that is, there are two employees who like each other, then we can arrange these two employees together. If these two employees are each liked by other employees, then we only need to arrange the employees who like them next to them. If there are multiple such situations, we can arrange them all.
+
+Therefore, the problem is actually equivalent to finding the length of the maximum cycle in the graph, and all cycles of length $2$ plus their longest chain. The maximum of these two can be found. To find the longest chain to the cycle of length $2$, we can use topological sorting.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array `favorite`.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
 class Solution:
     def maximumInvitations(self, favorite: List[int]) -> int:
-        def max_cycle(fa):
+        def max_cycle(fa: List[int]) -> int:
             n = len(fa)
             vis = [False] * n
             ans = 0
@@ -87,13 +103,13 @@ class Solution:
                         break
             return ans
 
-        def topological_sort(fa):
+        def topological_sort(fa: List[int]) -> int:
             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])
+            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)

solution/2100-2199/2127.Maximum Employees to Be Invited to a Meeting/Solution.py

@@ -1,37 +1,37 @@
-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))
+class Solution:
+    def maximumInvitations(self, favorite: List[int]) -> int:
+        def max_cycle(fa: List[int]) -> int:
+            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: List[int]) -> int:
+            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))

solution/2100-2199/2127.Maximum Employees to Be Invited to a Meeting/Solution.ts

@@ -0,0 +1,55 @@
+function maximumInvitations(favorite: number[]): number {
+    return Math.max(maxCycle(favorite), topologicalSort(favorite));
+}
+
+function maxCycle(fa: number[]): number {
+    const n = fa.length;
+    const vis: boolean[] = Array(n).fill(false);
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (vis[i]) {
+            continue;
+        }
+        const cycle: number[] = [];
+        let j = i;
+        for (; !vis[j]; j = fa[j]) {
+            cycle.push(j);
+            vis[j] = true;
+        }
+        for (let k = 0; k < cycle.length; ++k) {
+            if (cycle[k] === j) {
+                ans = Math.max(ans, cycle.length - k);
+            }
+        }
+    }
+    return ans;
+}
+
+function topologicalSort(fa: number[]): number {
+    const n = fa.length;
+    const indeg: number[] = Array(n).fill(0);
+    const dist: number[] = Array(n).fill(1);
+    for (const v of fa) {
+        ++indeg[v];
+    }
+    const q: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (indeg[i] === 0) {
+            q.push(i);
+        }
+    }
+    let ans = 0;
+    while (q.length) {
+        const i = q.pop()!;
+        dist[fa[i]] = Math.max(dist[fa[i]], dist[i] + 1);
+        if (--indeg[fa[i]] === 0) {
+            q.push(fa[i]);
+        }
+    }
+    for (let i = 0; i < n; ++i) {
+        if (i === fa[fa[i]]) {
+            ans += dist[i];
+        }
+    }
+    return ans;
+}