# Solving Leetcode Interviews in Seconds with AI: Min Cost to Connect All Points


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1584" 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 array points representing integer coordinates of some points on a 2D-plane, where points[i] = [xi, yi]. The cost of connecting two points [xi, yi] and [xj, yj] is the manhattan distance between them: |xi - xj| + |yi - yj|, where |val| denotes the absolute value of val. Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.   Example 1:   Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]] Output: 20 Explanation:   We can connect the points as shown above to get the minimum cost of 20. Notice that there is a unique path between every pair of points.  Example 2:  Input: points = [[3,12],[-2,5],[-4,1]] Output: 18    Constraints:  1 <= points.length <= 1000 -106 <= xi, yi <= 106 All pairs (xi, yi) are distinct.  

	# Explanation
	Here's the breakdown of the solution:

*   **Minimum Spanning Tree:** The problem is equivalent to finding the Minimum Spanning Tree (MST) of a complete graph where nodes are the points and edge weights are the Manhattan distances.
*   **Prim's Algorithm:**  Prim's algorithm is used to efficiently construct the MST. It iteratively adds the minimum-weight edge that connects a visited node to an unvisited node.
*   **Optimization:** To avoid calculating all pairwise distances upfront, the distances are computed on-demand during the Prim's algorithm's iterations. A `min_cost` array keeps track of the minimum cost to connect each unvisited node to the current MST.

*   **Runtime Complexity:** O(N^2), where N is the number of points.  **Storage Complexity:** O(N)

	
	# Code
	```python
	import heapq

def minCostConnectPoints(points):
    n = len(points)
    if n <= 1:
        return 0

    adj = [[] for _ in range(n)]
    for i in range(n):
        for j in range(i + 1, n):
            dist = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])
            adj[i].append((dist, j))
            adj[j].append((dist, i))

    visited = [False] * n
    min_cost = [float('inf')] * n
    min_cost[0] = 0
    pq = [(0, 0)]  # (cost, node)
    total_cost = 0

    while pq:
        cost, u = heapq.heappop(pq)

        if visited[u]:
            continue
        visited[u] = True
        total_cost += cost

        for neighbor_cost, v in adj[u]:
            if not visited[v] and neighbor_cost < min_cost[v]:
                min_cost[v] = neighbor_cost
                heapq.heappush(pq, (neighbor_cost, v))

    return total_cost
	```