Introduction

In this blog post, we will explore how to solve the LeetCode problem "3372" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, 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

There exist two undirected trees with n and m nodes, with distinct labels in ranges [0, n - 1] and [0, m - 1], respectively. You are given two 2D integer arrays edges1 and edges2 of lengths n - 1 and m - 1, respectively, where edges1[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the first tree and edges2[i] = [ui, vi] indicates that there is an edge between nodes ui and vi in the second tree. You are also given an integer k. Node u is target to node v if the number of edges on the path from u to v is less than or equal to k. Note that a node is always target to itself. Return an array of n integers answer, where answer[i] is the maximum possible number of nodes target to node i of the first tree if you have to connect one node from the first tree to another node in the second tree. Note that queries are independent from each other. That is, for every query you will remove the added edge before proceeding to the next query. Example 1: Input: edges1 = [[0,1],[0,2],[2,3],[2,4]], edges2 = [[0,1],[0,2],[0,3],[2,7],[1,4],[4,5],[4,6]], k = 2 Output: [9,7,9,8,8] Explanation: For i = 0, connect node 0 from the first tree to node 0 from the second tree. For i = 1, connect node 1 from the first tree to node 0 from the second tree. For i = 2, connect node 2 from the first tree to node 4 from the second tree. For i = 3, connect node 3 from the first tree to node 4 from the second tree. For i = 4, connect node 4 from the first tree to node 4 from the second tree. Example 2: Input: edges1 = [[0,1],[0,2],[0,3],[0,4]], edges2 = [[0,1],[1,2],[2,3]], k = 1 Output: [6,3,3,3,3] Explanation: For every i, connect node i of the first tree with any node of the second tree. Constraints: 2 <= n, m <= 1000 edges1.length == n - 1 edges2.length == m - 1 edges1[i].length == edges2[i].length == 2 edges1[i] = [ai, bi] 0 <= ai, bi < n edges2[i] = [ui, vi] 0 <= ui, vi < m The input is generated such that edges1 and edges2 represent valid trees. 0 <= k <= 1000

Explanation

Here's the breakdown of the problem and the solution approach:

• Core Idea: For each node i in the first tree, iterate through all possible connection points in the second tree. For each connection, calculate the number of reachable nodes within the distance k in the combined graph. Keep track of the maximum reachable count.

• Distance Calculation: Use Breadth-First Search (BFS) to efficiently compute the distances from a starting node in both trees and the combined graph after adding an edge.

• Optimization: Precompute distances within each tree to avoid redundant calculations during the main loop.

• Complexity:

  • Runtime: O(n m (n + m)), where n and m are the number of nodes in the first and second trees, respectively.
  • Storage: O(n^2 + m^2), primarily for storing precomputed distances.

Code

    from collections import deque

def solve():
    def bfs(graph, start_node, n):
        dist = [[float('inf')] * n for _ in range(n)]
        for i in range(n):
            dist[i][i] = 0

        for start in range(n):
            q = deque([(start, 0)])  # (node, distance)
            dist[start][start] = 0
            visited = {start}

            while q:
                node, d = q.popleft()
                for neighbor in graph[node]:
                    if neighbor not in visited:
                        dist[start][neighbor] = d + 1
                        q.append((neighbor, d + 1))
                        visited.add(neighbor)
        return dist

    def count_reachable(dist, start_node, k, n):
        count = 0
        for i in range(n):
            if dist[start_node][i] <= k:
                count += 1
        return count

    def solve_internal(edges1, edges2, k):
        n = len(edges1) + 1
        m = len(edges2) + 1

        graph1 = [[] for _ in range(n)]
        for u, v in edges1:
            graph1[u].append(v)
            graph1[v].append(u)

        graph2 = [[] for _ in range(m)]
        for u, v in edges2:
            graph2[u].append(v)
            graph2[v].append(u)

        dist1 = bfs(graph1, 0, n)
        dist2 = bfs(graph2, 0, m)

        answer = []
        for i in range(n):
            max_reachable = 0
            for j in range(m):  # Try connecting node i to node j

                # Create a temporary graph by combining the two trees with an edge between i and j
                temp_graph = [[] for _ in range(n + m)]
                for u in range(n):
                    temp_graph[u] = graph1[u].copy()
                for u in range(m):
                    temp_graph[n + u] = graph2[u].copy()

                temp_graph[i].append(n + j)
                temp_graph[n + j].append(i)

                # Compute distances in the combined graph using BFS, but more efficiently
                temp_dist = [[float('inf')] * (n + m) for _ in range(n + m)]
                for start in range(n + m):
                    q = deque([(start, 0)])
                    temp_dist[start][start] = 0
                    visited = {start}

                    while q:
                        u, d = q.popleft()
                        for v in temp_graph[u]:
                            if v not in visited:
                                temp_dist[start][v] = d + 1
                                q.append((v, d + 1))
                                visited.add(v)


                reachable_count = 0
                for node_index in range(n):
                  if temp_dist[i][node_index] <= k:
                    reachable_count += 1

                max_reachable = max(max_reachable, reachable_count)
            answer.append(max_reachable)
        return answer

    # Example Usage (replace with actual input):
    edges1 = [[0,1],[0,2],[2,3],[2,4]]
    edges2 = [[0,1],[0,2],[0,3],[2,7],[1,4],[4,5],[4,6]]
    k = 2
    result = solve_internal(edges1, edges2, k)
    print(result)

solve()