leetcode1202. 交换字符串中的元素

题目描述：

给你一个字符串 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 中只含有小写英文字母

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/smallest-string-with-swaps
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解析：

通过pair可发现结点之间的连通状况，连通结点之间可以相互交换。

代码：

class uSet{
    public:
        vector<int> fa;
        vector<int> sSize;
        //构造函数
        uSet(int n):fa(n),sSize(n){
            for(int i=0;i<n;i++){
                fa[i]=i;
                sSize[i]=1;
            }
        }
        //递归找父亲，并改变沿途父节点
        int find(int m){
            if(m!=fa[m])
                fa[m]=find(fa[m]);
            return fa[m];
        }

        //合并两个集合
        void unionSet(int m,int n){
            int x=find(m);
            int y=find(n);
            if(x==y)
                return ;
            //y指向较大值
            if(sSize[x]>sSize[y])
                swap(x,y);
            //将x的父亲变成y,连接到y上
            fa[x]=y;
            sSize[y]+=sSize[x];
            sSize[x]=0;
        }
};
class Solution {
public:
    //同一个集合的可以排序
    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        int n=s.size();
        //结点初始化
        uSet ds(n);
        //合并连通结点
        for(int i=0;i<pairs.size();i++){
            ds.unionSet(pairs[i][0],pairs[i][1]);
        }
        for(int i=0;i<pairs.size();i++){
            //"dcab"  [[0,3],[1,2],[0,2]] 父结点值不全为2，需要将前边更新
            ds.unionSet(pairs[i][0],pairs[i][1]);
        }
        //相同父节点放到一起，
        unordered_map<int,priority_queue<char>> qmap;
        for(int i=0;i<n;i++){
            //父亲相同的，放到同一个优先队列中
            qmap[ds.fa[i]].push(s[i]);
        }
        //查看i对应父节点（通过fa），然后从map中取出最大值填充
        for(int i=n-1;i>=0;i--){
            s[i]=qmap[ds.fa[i]].top();
            qmap[ds.fa[i]].pop();
        }
        return s;
    }
};