并查集问题：LeetCode：1202. 交换字符串中的元素

给你一个字符串 s，以及该字符串中的一些「索引对」数组 pairs，其中 pairs[i] = [a, b] 表示字符串中的两个索引（编号从 0 开始）。

你可以 任意多次交换 在 pairs 中任意一对索引处的字符。

返回在经过若干次交换后，s 可以变成的按字典序最小的字符串。

示例 1:

输入：s = “dcab”, pairs = [[0,3],[1,2]]
输出：“bacd”
解释：
交换 s[0] 和 s[3], s = “bcad”
交换 s[1] 和 s[2], s = “bacd”
示例 2：

输入：s = “dcab”, pairs = [[0,3],[1,2],[0,2]]
输出：“abcd”
解释：
交换 s[0] 和 s[3], s = “bcad”
交换 s[0] 和 s[2], s = “acbd”
交换 s[1] 和 s[2], s = “abcd”
示例 3：

输入：s = “cba”, pairs = [[0,1],[1,2]]
输出：“abc”
解释：
交换 s[0] 和 s[1], s = “bca”
交换 s[1] 和 s[2], s = “bac”
交换 s[0] 和 s[1], s = “abc”

提示：

1 <= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s 中只含有小写英文字母

一 解题思路

//解题思路，将可以建立联系的边放到一个集合里，将每一个集合里的字符排序，就得到了最小的字典序。
//难点在于在同一个集合里的字符怎么排序以及排序后如何插入原字符串。本题目是采用Hashmap，char数组，sb完成。

二 代码实现

class Solution {
     
    public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
     
        DisJU dju = new DisJU(100000 + 5);
        //将pair里面能建立联系的边联系起来
        for (List<Integer> list : pairs) {
     
            dju.union(list.get(0), list.get(1));
        }
        //将路径压缩后的 祖先节点当做key,他的子节点构成的List当做值。
        HashMap<Integer, List<Integer>> hs = new HashMap<>();
        for (int i = 0; i < s.length(); ++i) {
     
            int key = dju.find(i);
            hs.computeIfAbsent(key, k -> new ArrayList<>()).add(i);//如果list不存在，newList 再add
        }
        //方便字符串修改，采用sb
        StringBuilder sb = new StringBuilder(s);
        for (List<Integer> idx_list : hs.values()) {
     
            if (idx_list.size() > 1) {
     
                //mysort 的方法是将 同一个集合里的对应字符取出放在char数组里面，排序后，按照数组顺序插入原字符串。
                mysort(sb, idx_list);
            }
        }
        return sb.toString();
    }
    private void mysort(StringBuilder sb, List<Integer> idx_list) {
     
        //这种写法是错误的，建立一个char数组，但是你不填满，sort之后，null和字符会重新排序，并不会做到值排序有值的区域的字符。
//        char[] chars = new char[sb.length()];
//        for (int idx:idx_list){
     
//            chars[idx] = sb.charAt(idx);//在char数组对应idx处填上sb中的字符
//        }
//        Arrays.sort(chars);
//        for (int idx:idx_list){
     
//            sb.setCharAt(idx,chars[idx]);
//        }
//    }
        char[] chars = new char[idx_list.size()];
        for (int i = 0; i < idx_list.size(); ++i) {
     
            chars[i] = sb.charAt(idx_list.get(i));
        }
        Arrays.sort(chars);
        for (int i = 0; i < idx_list.size(); ++i) {
     
            sb.setCharAt(idx_list.get(i), chars[i]);
        }

    }
}

class DisJU{
     
    int[] pre;
    public DisJU(){
     }
    public DisJU(int n){
     
        pre = new int[n];
        for (int i=0;i<n;++i){
     
            pre[i]=i;
        }
    }
    public int find(int x ){
     
        if (pre[x]==x)return x;
        int root = find(pre[x]);
        return pre[x]=root;
    }
    public void union(int a ,int b){
     
        int x = find(a);
        int y = find(b);
        pre[x]=y;
    }
}