2026 March 14 Problems

daryl...@gmail.com

unread,

Mar 14, 2026, 12:44:09 PMMar 14

to leetcode-meetup

Feel free to work on any of the problems you want; we'll have people present their solutions at 11:30.

Please post your solutions to this thread so others can use this as a reference.

226. Invert Binary Tree Easy 79.9%

2192. All Ancestors of a Node in a Directed Acyclic Graph Medium 62.1%

2092. Find All People With Secret Hard 48.5%

Anuj Patnaik

unread,

Mar 14, 2026, 1:30:14 PMMar 14

to leetcode-meetup

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root == None:
            return None
        temp = root.right
        root.right = root.left
        root.left = temp
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

Allen S.

unread,

Mar 14, 2026, 1:49:57 PMMar 14

to leetcode-meetup

func invertTree(root *TreeNode) *TreeNode {
    if root == nil {
        return nil
    }
    // swap
    root.Left, root.Right = invertTree(root.Right), invertTree(root.Left)
    return root
}

Jagrut Sharma

unread,

Mar 14, 2026, 2:18:10 PMMar 14

to leetcod...@googlegroups.com

226. Invert Binary Tree

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:

        if root:
            q = deque([root])
            while q:
                curr_node = q.popleft()
                curr_node.left, curr_node.right = curr_node.right, curr_node.left
                if curr_node.left:
                    q.append(curr_node.left)
                if curr_node.right:
                    q.append(curr_node.right)
        return root

2192. All Ancestors of a Node in a Directed Acyclic Graph

class Solution:
    def getAncestors(self, n: int, edges: List[List[int]]) -> List[List[int]]:
        g = defaultdict(list)
        in_degree = [0] * n
        for start, end in edges:
            g[start].append(end)
            in_degree[end] += 1
        ancestors = [set() for _ in range(n)]
        candidates = [i for i in range(n) if in_degree[i] == 0]
        q = deque(candidates)
        while q:
            curr = q.popleft()
            for nei in g[curr]:
                ancestors[nei].add(curr)
                ancestors[nei].update(ancestors[curr])
                in_degree[nei] -= 1
                if in_degree[nei] == 0:
                    q.append(nei)
        return [sorted(list(s)) for s in ancestors]

--
whatspp group: http://whatsapp.techbayarea.us/
---
You received this message because you are subscribed to the Google Groups "leetcode-meetup" group.
To unsubscribe from this group and stop receiving emails from it, send an email to leetcode-meet...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/leetcode-meetup/8029466b-ebc5-4442-8620-c53c9e660aacn%40googlegroups.com.

--

Jagrut

Anuj Patnaik

unread,

Mar 14, 2026, 2:21:27 PMMar 14

to leetcode-meetup

class Solution:
    def findAllPeople(self, n: int, meetings: List[List[int]], firstPerson: int) -> List[int]:
        meetings.sort(key=lambda x: x[2])
        secret_ppl = {0, firstPerson}
        i = 0
        while i < len(meetings):
            time_i = meetings[i][2]
            same_time = []
            j = i 
            while j < len(meetings) and meetings[j][2] == time_i:
                same_time.append(meetings[j])
                j += 1
            graph = defaultdict(list)
            for m in same_time:
                x_m = m[0]
                y_m = m[1]
                graph[x_m].append(y_m)
                graph[y_m].append(x_m)
            visited = set()
            for person in graph:
                if person in secret_ppl and person not in visited:
                    stack = [person]
                    while len(stack) > 0:
                        p = stack.pop()
                        if p in visited:
                            continue
                        visited.add(p)
                        secret_ppl.add(p)
                        for partner in graph[p]:
                            if partner not in visited:
                                stack.append(partner)
            i = j
        return list(secret_ppl)

Jagrut

unread,

Mar 14, 2026, 2:28:27 PMMar 14

to leetcode-meetup

2092. Find All People With Secret 

class Solution:
    def findAllPeople(self, n: int, meetings: List[List[int]], firstPerson: int) -> List[int]:

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

        time_map = defaultdict(list)
        for x, y, t in meetings:
            time_map[t].append((x, y))

        for t in sorted(time_map):
            group = set()
            for x, y in time_map[t]:
                uf.union(x, y)
                group.add(x)
                group.add(y)

            for person in group:
                if not uf.connected(person, 0):
                    uf.reset(person)

        return [i for i in range(n) if uf.connected(i, 0)]

    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):
            self.parent[self.find(x)] = self.find(y)

        def connected(self, x, y):
            return self.find(x) == self.find(y)

        def reset(self, x):
            self.parent[x] = x

On Saturday, March 14, 2026 at 9:44:09 AM UTC-7 daryl...@gmail.com wrote:

daryl...@gmail.com

unread,

Mar 14, 2026, 2:32:23 PMMar 14

to leetcode-meetup

Realized I forgot the meeting link, which is the same as before: https://meet.google.com/xnn-kifj-jnx?pli=1

On Saturday, March 14, 2026 at 9:44:09 AM UTC-7 daryl...@gmail.com wrote:

James Zhou

unread,

Mar 14, 2026, 3:50:57 PMMar 14

to leetcode-meetup

226. Invert Binary Tree

Python

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:

        if not root:
            return None

        root.left, root.right = root.right, root.left

        self.invertTree(root.left)
        self.invertTree(root.right)

        return root

Allen S.

unread,

Mar 14, 2026, 4:07:21 PMMar 14

to leetcode-meetup

// hint based solution
func getAncestors(n int, edges [][]int) [][]int {
    g := make([][]int, n) // reversed adj list
    parents := make([]bool, n)
    for _, v := range edges {
        g[v[1]] = append(g[v[1]], v[0])
        parents[v[0]] = true
    }

    ancestors := make([][]bool, n) 
    for i := range n {
        ancestors[i] = make([]bool, n)
    }

    visited := make([]bool, n)
    var dfs func(i int, descendants  []int) // i is node
    dfs = func(i int, descendants []int) {
        if visited[i] {
            for _, des := range descendants  {
                ancestors[des][i] = true
                for anc, ok := range ancestors[i] {
                    if ok {
                        ancestors[des][anc] = true
                    }
                }
            }
            // fmt.Printf("already visited node %v\n", i)
            return
        }
        // fmt.Printf("visiting node %v \n", i)

        visited[i] = true

        for _, v := range descendants  {
            ancestors[v][i] = true
        }
        for _, next := range g[i] {
            dfs(next, append(descendants , i))
        }
    }

    for i, ok := range parents {
        if !ok { // nonParents
            // fmt.Printf("visiting nonParent %v\n", i)
            dfs(i, []int{})
        }
    }

    res := make([][]int, n)
    for i, v := range ancestors {
        for j := range v {
            if ancestors[i][j] {
                res[i] = append(res[i], j)
            }
        }
    }
    return res
}

vinay

unread,

Mar 15, 2026, 12:46:02 PMMar 15

to leetcod...@googlegroups.com

2192. All Ancestors of a Node in a Directed Acyclic Graph Medium 62.1%

using topological sorting and ancestor propagation.

time O(V^2 + E)

space O(V^2) for storing nodes

class Solution {
    public List<List<Integer>> getAncestors(int n, int[][] edges) {
        int[] indegree = new int[n];
        Map<Integer, List<Integer>> adjacency = new HashMap<>();
        Deque<Integer> queue = new ArrayDeque<>();
        Set[] ancestors = new TreeSet[n];
        List<List<Integer>> result = new ArrayList<>();

        for(int[] edge : edges){
            int from = edge[0];
            int to = edge[1];
            indegree[to]++;
            adjacency.computeIfAbsent(from, k -> new ArrayList<>()).add(to);
        }

        for(int i = 0; i < n; i++){
            if(indegree[i] == 0){
                queue.offer(i);
                ancestors[i] = new TreeSet<>();
            }
        }

        while(queue.size() > 0){
            int node = queue.poll();

            for(int child : adjacency.getOrDefault(node, new ArrayList<>())){
                if(ancestors[child] == null){
                    ancestors[child] = new TreeSet<>();
                }
                ancestors[child].addAll(ancestors[node]);
                ancestors[child].add(node);
                indegree[child]--;
                if(indegree[child] == 0){
                    queue.offer(child);
                }
            }
        }

        for(int i = 0; i < n; i++){
            List<Integer> ancestorList = ancestors[i] == null ? new ArrayList<>() : new ArrayList(ancestors[i]);
            result.add(ancestorList);
        }

        return result;
    }
}

--
whatspp group: http://whatsapp.techbayarea.us/
---
You received this message because you are subscribed to the Google Groups "leetcode-meetup" group.
To unsubscribe from this group and stop receiving emails from it, send an email to leetcode-meet...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/leetcode-meetup/d95eb30f-5a70-4761-b23b-108d63ede5d1n%40googlegroups.com.

vinay

unread,

Mar 15, 2026, 1:00:31 PMMar 15

to leetcod...@googlegroups.com

226. Invert Binary Tree

class Solution {
    public TreeNode invertTree(TreeNode root) {
        
        if(root == null){
            return root;
        }
        
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);

        TreeNode tmp = root.left;

        root.left = right;
        root.right = tmp;

        return root;
    }
}

Reply all

Reply to author

Forward