Connecting Cities With Minimum Cost

There are N cities numbered from 1 to N.

You are given connections, where each connections[i] = [city1, city2, cost] represents the cost to connect city1 and city2 together.  (A connection is bidirectional: connecting city1 and city2 is the same as connecting city2 and city1.)

Return the minimum cost so that for every pair of cities, there exists a path of connections (possibly of length 1) that connects those two cities together.  The cost is the sum of the connection costs used. If the task is impossible, return -1.

 

Example 1:

Input: N = 3, connections = [[1,2,5],[1,3,6],[2,3,1]]
Output: 6
Explanation: 
Choosing any 2 edges will connect all cities so we choose the minimum 2.
Example 2:

Input: N = 4, connections = [[1,2,3],[3,4,4]]
Output: -1
Explanation: 
There is no way to connect all cities even if all edges are used.
 

Note:

  1. 1 <= N <= 10000
  2. 1 <= connections.length <= 10000
  3. 1 <= connections[i][0], connections[i][1] <= N
  4. 0 <= connections[i][2] <= 10^5
  5. connections[i][0] != connections[i][1]

Solution:

class Solution {
    class UF {
        int[] sizes;
        int[] parents;
        int count;
        
        public UF(int n) {
            sizes = new int[n + 1];
            parents = new int[n + 1];
            count = n;
            for (int i = 1; i <= n; i ++) {
                sizes[i] = 1;
                parents[i] = i;
            }
        }
        
        public int find(int x) {
            while (parents[x] != x) {
                parents[x] = parents[parents[x]];
                x = parents[x];
            }
            return x;
        }
        
        public void union(int x, int y) {
            int rootX = find(x);
            int rootY= find(y);
            if (rootX == rootY) return;
            if (sizes[rootX] > sizes[rootY]) {
                parents[rootY] = rootX;
                sizes[rootX] += sizes[rootY];
            } else {
                parents[rootX] = rootY;
                sizes[rootY] += sizes[rootX];
            }
            count --;
        }
        
        public boolean connected(int x, int y) {
            return find(x) == find(y);
        }
    }
    
    public int minimumCost(int N, int[][] connections) {
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> { return Integer.compare(a[2], b[2]); });
        UF cities = new UF(N);
        for (int[] conn : connections) {
            pq.offer(conn);
        }
        int cost = 0;
        while (!pq.isEmpty()) {
            int[] conn = pq.poll();
            if (!cities.connected(conn[0], conn[1])) {
                cities.union(conn[0], conn[1]);
                cost += conn[2];
            }
        }
        if (cities.count != 1) return -1;
        return cost;
    }
}