Sync LeetCode submission Runtime - 159 ms (93.75%), Memory - 31.5 MB (70.67%)

Author: jimit105

2246-maximum-employees-to-be-invited-to-a-meeting/README.md

@@ -0,0 +1,54 @@
+<p>A company is organizing a meeting and has a list of <code>n</code> employees, waiting to be invited. They have arranged for a large <strong>circular</strong> table, capable of seating <strong>any number</strong> of employees.</p>
+
+<p>The employees are numbered from <code>0</code> to <code>n - 1</code>. Each employee has a <strong>favorite</strong> person and they will attend the meeting <strong>only if</strong> they can sit next to their favorite person at the table. The favorite person of an employee is <strong>not</strong> themself.</p>
+
+<p>Given a <strong>0-indexed</strong> integer array <code>favorite</code>, where <code>favorite[i]</code> denotes the favorite person of the <code>i<sup>th</sup></code> employee, return <em>the <strong>maximum number of employees</strong> that can be invited to the meeting</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/14/ex1.png" style="width: 236px; height: 195px;" />
+<pre>
+<strong>Input:</strong> favorite = [2,2,1,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The above figure shows how the company can invite employees 0, 1, and 2, and seat them at the round table.
+All employees cannot be invited because employee 2 cannot sit beside employees 0, 1, and 3, simultaneously.
+Note that the company can also invite employees 1, 2, and 3, and give them their desired seats.
+The maximum number of employees that can be invited to the meeting is 3. 
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> favorite = [1,2,0]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+Each employee is the favorite person of at least one other employee, and the only way the company can invite them is if they invite every employee.
+The seating arrangement will be the same as that in the figure given in example 1:
+- Employee 0 will sit between employees 2 and 1.
+- Employee 1 will sit between employees 0 and 2.
+- Employee 2 will sit between employees 1 and 0.
+The maximum number of employees that can be invited to the meeting is 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/14/ex2.png" style="width: 219px; height: 220px;" />
+<pre>
+<strong>Input:</strong> favorite = [3,0,1,4,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+The above figure shows how the company will invite employees 0, 1, 3, and 4, and seat them at the round table.
+Employee 2 cannot be invited because the two spots next to their favorite employee 1 are taken.
+So the company leaves them out of the meeting.
+The maximum number of employees that can be invited to the meeting is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == favorite.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= favorite[i] &lt;=&nbsp;n - 1</code></li>
+	<li><code>favorite[i] != i</code></li>
+</ul>

2246-maximum-employees-to-be-invited-to-a-meeting/solution.py

@@ -0,0 +1,55 @@
+# Approach 2: Topological Sort to Reduce Non-Cyclic Nodes
+
+# Time: O(n)
+# Space: O(n)
+
+from collections import deque
+
+class Solution:
+    def maximumInvitations(self, favorite: List[int]) -> int:
+        n = len(favorite)
+        in_degree = [0] * n
+
+        # calculate in-degree for each node
+        for person in range(n):
+            in_degree[favorite[person]] += 1
+
+        # topological sorting to remove non-cycle nodes
+        q = deque()
+        for person in range(n):
+            if in_degree[person] == 0:
+                q.append(person)
+        depth = [1] * n # depth for each node
+
+        while q:
+            current_node = q.popleft()
+            next_node = favorite[current_node]
+            depth[next_node] = max(depth[next_node], depth[current_node] + 1)
+            in_degree[next_node] -= 1
+            if in_degree[next_node] == 0:
+                q.append(next_node)
+
+        longest_cycle = 0
+        two_cycle_invitations = 0
+
+        # Detect cycles
+        for person in range(n):
+            if in_degree[person] == 0: # Already processed
+                continue
+
+            cycle_length = 0
+            current = person
+
+            while in_degree[current] != 0:
+                in_degree[current] = 0 # mark as visited
+                cycle_length += 1
+                current = favorite[current]
+
+            if cycle_length == 2:
+                # for 2-cycles, add the depth of both nodes
+                two_cycle_invitations += depth[person] + depth[favorite[person]]
+            else:
+                longest_cycle = max(longest_cycle, cycle_length)
+
+        return max(longest_cycle, two_cycle_invitations)
+