<p>You are given an array <code>points</code> representing integer coordinates of some points on a 2D-plane, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>.</p>

<p>The cost of connecting two points <code>[x<sub>i</sub>, y<sub>i</sub>]</code> and <code>[x<sub>j</sub>, y<sub>j</sub>]</code> is the <strong>manhattan distance</strong> between them: <code>|x<sub>i</sub> - x<sub>j</sub>| + |y<sub>i</sub> - y<sub>j</sub>|</code>, where <code>|val|</code> denotes the absolute value of <code>val</code>.</p>

<p>Return <em>the minimum cost to make all points connected.</em> All points are connected if there is <strong>exactly one</strong> simple path between any two points.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/26/d.png" style="width: 214px; height: 268px;" />
<pre>
<strong>Input:</strong> points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
<strong>Output:</strong> 20
<strong>Explanation:</strong> 
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/26/c.png" style="width: 214px; height: 268px;" />
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.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> points = [[3,12],[-2,5],[-4,1]]
<strong>Output:</strong> 18
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= points.length &lt;= 1000</code></li>
	<li><code>-10<sup>6</sup> &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>6</sup></code></li>
	<li>All pairs <code>(x<sub>i</sub>, y<sub>i</sub>)</code> are distinct.</li>
</ul>

class Solution:
    def minCostConnectPoints(self, points: List[List[int]]) -> int:
        # edges = []
        # n = len(points)
        # if n == 1:
        #     return 0

        # # adjacency list / graph
        # graph = {i : [] for i in range(n)}        
     
        # # calculate edges and their weights
        # for i in range(0, n - 1):
        #     x1, y1 = points[i]
        #     for j in range(i + 1, n):
        #         x2, y2 = points[j]
        #         dist = abs(x1 - x2) + abs(y1 - y2)
        #         graph[i].append([dist, j])
        #         graph[j].append([dist, i])
                
        # visited = set()
        # weightSum = 0
    
        # # select one random node
        # minHeap = []
        # visited.add(0)
        # for w, n2 in graph[0]:
        #     minHeap.append([w, n2])
        # heapq.heapify(minHeap)    
        
        # while len(visited) < n:
        #     w, n1 = heapq.heappop(minHeap)
        #     if n1 in visited:
        #         continue   

        #     visited.add(n1) 
        #     weightSum += w   
        #     for w1, n1 in graph[n1]:
        #         if n1 not in visited:
        #             heapq.heappush(minHeap, [w1, n1])
    
        # return weightSum

        n = len(points)
    
        edges = []
        for i in range(n):
            x1, y1 = points[i]
            for j in range(i+1, n):
                x2, y2 = points[j]    
                dist = abs(x1 - x2) + abs(y1 - y2)
                edges.append([dist, i, j])
                edges.append([dist, j, i])

        edges.sort(key = lambda x : x[0])        

        parent = [i for i in range(n)]
        size = [1] * n

        def find(n):
            if parent[n] == n:
                return n
            
            n1 = find(parent[n])
            parent[n] = n1
            return n1

        def union(n1, n2):
            r1, r2 = find(n1), find(n2)

            if r1 == r2:
                return False
            if size[r1] > size[r2]:
                size[r1] += size[r2]
                parent[r2] = parent[r1]
            else:
                parent[r1] = parent[r2]
                size[r2] += size[r1]

            return True    

        res, number = 0, 0
        for w, n1, n2 in edges:
            if union(n1, n2):
                res += w
                number += 1
            if number == n - 1:
                break

        return res
166168