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 中只含有小写英文字母

一：并查集
能够互相交换的索引，是相互连通的，此集合内的元素都可互相交换。
所以将能够连通的字符集合存入优先队列（小根堆）中，或者存入数组中然后排序

class Solution {
public:
    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        int n = s.size();
        vector<int> parent(n);
        //初始化
        for(int i=0; i<n; i++){
            parent[i] = i;
        }
        //合并
        for(auto& pair : pairs){
            merge(parent, pair[0], pair[1]);
        }
        //优先队列
        unordered_map<int, priority_queue<char, vector<char>,greater<char>>> map;

        for(int i=0; i<n; i++){
            //此处使用find()，更新父节点
            int root = find(parent, i);
            //将父节点相同的下标加入到同一个优先队列中
            map[root].emplace(s[i]);
        }

        for(int i=0; i<n; i++){
            //此处直接使用parent
            s[i] = map[parent[i]].top();
            map[parent[i]].pop();
        }
        return s;
    }

    int find(vector<int>& parent, int x){
        int root = x;
        while(parent[root] != root){
            root = parent[root];
        }
        //更新，使x直接指向父节点，parent[x] == root;
        while(parent[x] != root){
            int ans = parent[x];
            parent[x] = root;
            x = ans;
        }
        return root;
    }

    void merge(vector<int>& parent, int x, int y){
        int x_root = find(parent, x);
        int y_root = find(parent, y);
        if(x_root == y_root) return;
        parent[x_root] = y_root;
    }
};