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
Example 3:
Input: points = [[0,0],[1,1],[1,0],[-1,1]]
Output: 4
Example 4:
Input: points = [[-1000000,-1000000],[1000000,1000000]]
Output: 4000000
Example 5:
Input: points = [[0,0]]
Output: 0
Constraints:
1 <= points.length <= 1000
-106 <= xi, yi <= 106
All pairs (xi, yi) are distinct.
from heapq import heappush, heappop

class UnionFind:
    def __init__(self, n):
        self.group = list(range(n))
        self.size = [0] * n
    
    def find(self, i):
        if i == self.group[i]:
            return i
        p = self.find(self.group[i])
        self.group[i] = p
        return p
    
    def union(self, i, j):
        i = self.find(i)
        j = self.find(j)
        if self.size[i] <= self.size[j]:
            self.group[i] = j
            self.size[j] += self.size[i]
        else:
            self.group[j] = i
            self.size[i] += self.size[j]

class Solution:
    def minCostConnectPoints(self, points: List[List[int]]) -> int:
        # minuim spining tree
        weights = []
        for i in range(len(points) - 1):
            for j in range(i + 1, len(points)):
                weight = abs(points[i][0]-points[j][0]) + abs(points[i][1]-points[j][1])
                heappush(weights, (weight, i,j))
                
                
        # print(weights)
        uf = UnionFind(len(points))
        res = 0
        
        while weights:
            min_edge, i, j = heappop(weights)
            if uf.find(i) == uf.find(j):
                continue
            uf.union(i, j)
            res += min_edge
                
        return res
            
            
        
      

            

from heapq import heappush, heappop

class UnionFind:
    def __init__(self, n):
        self.group = list(range(n))
        self.size = [0] * n
    
    def find(self, i):
        if i == self.group[i]:
            return i
        p = self.find(self.group[i])
        self.group[i] = p
        return p
    
    def union(self, i, j):
        i = self.find(i)
        j = self.find(j)
        if self.size[i] <= self.size[j]:
            self.group[i] = j
            self.size[j] += self.size[i]
        else:
            self.group[j] = i
            self.size[i] += self.size[j]

class Solution:
    def minCostConnectPoints(self, points: List[List[int]]) -> int:
        # minuim spining tree
        weights = []
        for i in range(len(points) - 1):
            for j in range(i + 1, len(points)):
                weight = abs(points[i][0]-points[j][0]) + abs(points[i][1]-points[j][1])
                heappush(weights, (weight, i,j))
                
                
        # print(weights)
        uf = UnionFind(len(points))
        res = 0
        
        while weights:
            min_edge, i, j = heappop(weights)
            if uf.find(i) == uf.find(j):
                continue
            uf.union(i, j)
            res += min_edge
                
        return res
            
            
        
      

            
