# Solving Leetcode Interviews in Seconds with AI: Find All People With Secret


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2092" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an integer n indicating there are n people numbered from 0 to n - 1. You are also given a 0-indexed 2D integer array meetings where meetings[i] = [xi, yi, timei] indicates that person xi and person yi have a meeting at timei. A person may attend multiple meetings at the same time. Finally, you are given an integer firstPerson. Person 0 has a secret and initially shares the secret with a person firstPerson at time 0. This secret is then shared every time a meeting takes place with a person that has the secret. More formally, for every meeting, if a person xi has the secret at timei, then they will share the secret with person yi, and vice versa. The secrets are shared instantaneously. That is, a person may receive the secret and share it with people in other meetings within the same time frame. Return a list of all the people that have the secret after all the meetings have taken place. You may return the answer in any order.   Example 1:  Input: n = 6, meetings = [[1,2,5],[2,3,8],[1,5,10]], firstPerson = 1 Output: [0,1,2,3,5] Explanation: At time 0, person 0 shares the secret with person 1. At time 5, person 1 shares the secret with person 2. At time 8, person 2 shares the secret with person 3. At time 10, person 1 shares the secret with person 5.​​​​ Thus, people 0, 1, 2, 3, and 5 know the secret after all the meetings.  Example 2:  Input: n = 4, meetings = [[3,1,3],[1,2,2],[0,3,3]], firstPerson = 3 Output: [0,1,3] Explanation: At time 0, person 0 shares the secret with person 3. At time 2, neither person 1 nor person 2 know the secret. At time 3, person 3 shares the secret with person 0 and person 1. Thus, people 0, 1, and 3 know the secret after all the meetings.  Example 3:  Input: n = 5, meetings = [[3,4,2],[1,2,1],[2,3,1]], firstPerson = 1 Output: [0,1,2,3,4] Explanation: At time 0, person 0 shares the secret with person 1. At time 1, person 1 shares the secret with person 2, and person 2 shares the secret with person 3. Note that person 2 can share the secret at the same time as receiving it. At time 2, person 3 shares the secret with person 4. Thus, people 0, 1, 2, 3, and 4 know the secret after all the meetings.    Constraints:  2 <= n <= 105 1 <= meetings.length <= 105 meetings[i].length == 3 0 <= xi, yi <= n - 1 xi != yi 1 <= timei <= 105 1 <= firstPerson <= n - 1  

	# Explanation
	Here's a breakdown of the solution approach and the corresponding Python code:

*   **Sort Meetings by Time:**  Process meetings in chronological order to simulate the spread of the secret over time accurately.
*   **Group Meetings by Time:** Efficiently handle simultaneous meetings by grouping them. This allows us to identify all people involved in meetings at a particular time.
*   **Union-Find with Time Constraints:**  Use the Union-Find data structure to track connected components (groups of people who share the secret).  Crucially, reset the connected components at the end of each time interval to ensure people who *don't* yet have the secret at a specific time don't inadvertently get it early.

*   **Runtime Complexity:** O(M log M + M α(N)), where M is the number of meetings and α(N) is the inverse Ackermann function (effectively constant).  The M log M comes from sorting the meetings. The M α(N) part comes from Union-Find operations.
*   **Storage Complexity:** O(N + M), where N is the number of people and M is the number of meetings. The O(N) comes from the parent array in Union-Find and the O(M) comes from storing the sorted meetings.

	
	# Code
	```python
	class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x != root_y:
            self.parent[root_x] = root_y


def findAllPeople(n: int, meetings: list[list[int]], firstPerson: int) -> list[int]:
    meetings.sort(key=lambda x: x[2])  # Sort meetings by time

    uf = UnionFind(n)
    uf.union(0, firstPerson)

    i = 0
    while i < len(meetings):
        time = meetings[i][2]
        group = []
        j = i
        while j < len(meetings) and meetings[j][2] == time:
            x, y, _ = meetings[j]
            uf.union(x, y)
            group.append(x)
            group.append(y)
            j += 1

        # Reset people who didn't have the secret at this time
        for person in set(group):
            if uf.find(person) != uf.find(0):
                uf.parent[person] = person

        i = j

    result = []
    for person in range(n):
        if uf.find(person) == uf.find(0):
            result.append(person)

    return result
	```