Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Break down a hard problem into reliable checkpoints, edge-case handling, and complexity trade-offs.
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 <= 1051 <= meetings.length <= 105meetings[i].length == 30 <= xi, yi <= n - 1xi != yi1 <= timei <= 1051 <= firstPerson <= n - 1Problem summary: 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
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Union-Find
6 [[1,2,5],[2,3,8],[1,5,10]] 1
4 [[3,1,3],[1,2,2],[0,3,3]] 3
5 [[3,4,2],[1,2,1],[2,3,1]] 1
reachable-nodes-in-subdivided-graph)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2092: Find All People With Secret
class Solution {
public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
boolean[] vis = new boolean[n];
vis[0] = true;
vis[firstPerson] = true;
int m = meetings.length;
Arrays.sort(meetings, Comparator.comparingInt(a -> a[2]));
for (int i = 0; i < m;) {
int j = i;
for (; j + 1 < m && meetings[j + 1][2] == meetings[i][2];) {
++j;
}
Map<Integer, List<Integer>> g = new HashMap<>();
Set<Integer> s = new HashSet<>();
for (int k = i; k <= j; ++k) {
int x = meetings[k][0], y = meetings[k][1];
g.computeIfAbsent(x, key -> new ArrayList<>()).add(y);
g.computeIfAbsent(y, key -> new ArrayList<>()).add(x);
s.add(x);
s.add(y);
}
Deque<Integer> q = new ArrayDeque<>();
for (int u : s) {
if (vis[u]) {
q.offer(u);
}
}
while (!q.isEmpty()) {
int u = q.poll();
for (int v : g.getOrDefault(u, List.of())) {
if (!vis[v]) {
vis[v] = true;
q.offer(v);
}
}
}
i = j + 1;
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < n; ++i) {
if (vis[i]) {
ans.add(i);
}
}
return ans;
}
}
// Accepted solution for LeetCode #2092: Find All People With Secret
func findAllPeople(n int, meetings [][]int, firstPerson int) []int {
vis := make([]bool, n)
vis[0], vis[firstPerson] = true, true
sort.Slice(meetings, func(i, j int) bool {
return meetings[i][2] < meetings[j][2]
})
for i, j, m := 0, 0, len(meetings); i < m; i = j + 1 {
j = i
for j+1 < m && meetings[j+1][2] == meetings[i][2] {
j++
}
g := map[int][]int{}
s := map[int]bool{}
for _, e := range meetings[i : j+1] {
x, y := e[0], e[1]
g[x] = append(g[x], y)
g[y] = append(g[y], x)
s[x], s[y] = true, true
}
q := []int{}
for u := range s {
if vis[u] {
q = append(q, u)
}
}
for len(q) > 0 {
u := q[0]
q = q[1:]
for _, v := range g[u] {
if !vis[v] {
vis[v] = true
q = append(q, v)
}
}
}
}
var ans []int
for i, v := range vis {
if v {
ans = append(ans, i)
}
}
return ans
}
# Accepted solution for LeetCode #2092: Find All People With Secret
class Solution:
def findAllPeople(
self, n: int, meetings: List[List[int]], firstPerson: int
) -> List[int]:
vis = [False] * n
vis[0] = vis[firstPerson] = True
meetings.sort(key=lambda x: x[2])
i, m = 0, len(meetings)
while i < m:
j = i
while j + 1 < m and meetings[j + 1][2] == meetings[i][2]:
j += 1
s = set()
g = defaultdict(list)
for x, y, _ in meetings[i : j + 1]:
g[x].append(y)
g[y].append(x)
s.update([x, y])
q = deque([u for u in s if vis[u]])
while q:
u = q.popleft()
for v in g[u]:
if not vis[v]:
vis[v] = True
q.append(v)
i = j + 1
return [i for i, v in enumerate(vis) if v]
// Accepted solution for LeetCode #2092: Find All People With Secret
/**
* [2092] Find All People With Secret
*
* 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 <= 10^5
* 1 <= meetings.length <= 10^5
* meetings[i].length == 3
* 0 <= xi, yi <= n - 1
* xi != yi
* 1 <= timei <= 10^5
* 1 <= firstPerson <= n - 1
*
*/
pub struct Solution {}
// problem: https://leetcode.com/problems/find-all-people-with-secret/
// discuss: https://leetcode.com/problems/find-all-people-with-secret/discuss/?currentPage=1&orderBy=most_votes&query=
// submission codes start here
impl Solution {
pub fn find_all_people(n: i32, meetings: Vec<Vec<i32>>, first_person: i32) -> Vec<i32> {
vec![]
}
}
// submission codes end
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[ignore]
fn test_2092_example_1() {
let n = 6;
let meetings = vec![vec![1, 2, 5], vec![2, 3, 8], vec![1, 5, 10]];
let first_person = 1;
let result = vec![0, 1, 2, 3, 5];
assert_eq!(Solution::find_all_people(n, meetings, first_person), result);
}
#[test]
#[ignore]
fn test_2092_example_2() {
let n = 4;
let meetings = vec![vec![3, 1, 3], vec![1, 2, 2], vec![0, 3, 3]];
let first_person = 3;
let result = vec![0, 1, 3];
assert_eq!(Solution::find_all_people(n, meetings, first_person), result);
}
#[test]
#[ignore]
fn test_2092_example_3() {
let n = 5;
let meetings = vec![vec![3, 4, 2], vec![1, 2, 1], vec![2, 3, 1]];
let first_person = 1;
let result = vec![0, 1, 2, 3, 4];
assert_eq!(Solution::find_all_people(n, meetings, first_person), result);
}
}
// Accepted solution for LeetCode #2092: Find All People With Secret
function findAllPeople(n: number, meetings: number[][], firstPerson: number): number[] {
const vis: boolean[] = Array(n).fill(false);
vis[0] = true;
vis[firstPerson] = true;
meetings.sort((x, y) => x[2] - y[2]);
for (let i = 0, m = meetings.length; i < m; ) {
let j = i;
while (j + 1 < m && meetings[j + 1][2] === meetings[i][2]) {
++j;
}
const g = new Map<number, number[]>();
const s = new Set<number>();
for (let k = i; k <= j; ++k) {
const x = meetings[k][0];
const y = meetings[k][1];
if (!g.has(x)) g.set(x, []);
if (!g.has(y)) g.set(y, []);
g.get(x)!.push(y);
g.get(y)!.push(x);
s.add(x);
s.add(y);
}
const q: number[] = [];
for (const u of s) {
if (vis[u]) {
q.push(u);
}
}
for (const u of q) {
for (const v of g.get(u)!) {
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
i = j + 1;
}
const ans: number[] = [];
for (let i = 0; i < n; ++i) {
if (vis[i]) {
ans.push(i);
}
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Track components with a list or adjacency matrix. Each union operation may need to update all n elements’ component labels, giving O(n) per union. For n union operations total: O(n²). Find is O(1) with direct lookup, but union dominates.
With path compression and union by rank, each find/union operation takes O(α(n)) amortized time, where α is the inverse Ackermann function — effectively constant. Space is O(n) for the parent and rank arrays. For m operations on n elements: O(m × α(n)) total.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.