[LeetCode] Minimum Spanning Tree

Given a list of Connections, which is the Connection class (the city name at both ends of the edge and a cost between them), find edges that can connect all the cities and spend the least amount.
Return the connects if can connect all the cities, otherwise return empty list.

Example

Example 1:

Input:
["Acity","Bcity",1]
["Acity","Ccity",2]
["Bcity","Ccity",3]
Output:
["Acity","Bcity",1]
["Acity","Ccity",2]

Example 2:

Input:
["Acity","Bcity",2]
["Bcity","Dcity",5]
["Acity","Dcity",4]
["Ccity","Ecity",1]
Output:
[]

Explanation:
No way

Notice

Return the connections sorted by the cost, or sorted city1 name if their cost is same, or sorted city2 if their city1 name is also same.

 

首先学习一下并查集的一些概念：

Disjoint Set: 对于Set里面的Node，只能属于一个Set。

支持两种操作：find（找到这个Node属于哪个Set）和 union（合并两个Set）

树是一种特例：

- Set指的是Root of the tree。这也很好理解，如果Node在一棵树上，那么他们share同一个树的Root。

- 复杂度：find(o(h)) - h means the height of the tree，union(o(1))

Reference：https://www.youtube.com/watch?v=UBY4sF86KEY

 

对于本道题（谁背谁会题），解法是先按照Cost Sort Connections。然后遍历Connections，查和并。如果两个node不属于一个Set，push到result list里。返回的时候检查一下result和点数目的关系（如果全部联通的话，Edge数应为Node数减1）。

代码如下。可以进一步优化：由于find的复杂度为树的高度，那么并的时候以更高的树的Root为Parent则可以减少find的复杂度。

/**
 * Definition for a Connection.
 * public class Connection {
 *   public String city1, city2;
 *   public int cost;
 *   public Connection(String city1, String city2, int cost) {
 *       this.city1 = city1;
 *       this.city2 = city2;
 *       this.cost = cost;
 *   }
 * }
 */
public class Solution {
    /**
     * @param connections given a list of connections include two cities and cost
     * @return a list of connections from results
     */
    Map<String, String> parents = new HashMap<>();
     
    public List<Connection> lowestCost(List<Connection> connections) {
        Collections.sort(connections, new MyComparator());
        
        List<Connection> res = new ArrayList<>();
        Set<String> nodes = new HashSet<>();
        
        for (Connection c : connections) {
            nodes.add(c.city1);
            nodes.add(c.city2);
            
            String s1 = find(c.city1);
            String s2 = find(c.city2);
            
            if (!s1.equals(s2)) {
                union(s1, s2);
                res.add(c);
            }
        }
        
        if (nodes.size() != (res.size() + 1)) {
            return new ArrayList<Connection>();
        }
        
        return res;
    }
    
    private String find(String x) {
        String curr = x;
        
        while (parents.get(curr) != null) {
            curr = parents.get(curr);
        }
        
        return curr;
    }
    
    private void union(String s1, String s2) {
        parents.put(s1, s2);
    }
    
    class MyComparator implements Comparator<Connection> {
        @Override
        public int compare(Connection a, Connection b) {
            if (a.cost != b.cost) {
                return a.cost - b.cost;
            }
            
            if (!a.city1.equals(b.city1)) {
                return a.city1.compareTo(b.city1);
            }
            
            return a.city2.compareTo(b.city2);
        }
    }
}