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

方法1：
主要思路：解题汇总链接
（1）使用交换数组建立邻接表的图；
（2）在图中进行广度优先搜索，将具有连通性质的结点存放到一起；
（3）将对存储连通性质的结点的数组进行遍历，将有连通性质的结点对应的字符从字符串中取出来进行排序，然后按照顺序重新放入字符串中；

class Solution {
public:
    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        unordered_map<int,vector<int>> mp;
        for(vector<int>&p:pairs){//建立邻接表的图
            mp[p[0]].push_back(p[1]);
            mp[p[1]].push_back(p[0]);
        }
        vector<vector<int>> paths;
        unordered_set<int> st;//标识访问过的结点
        for(auto&it:mp){//将各个具有连通性的结点找出，并存储
            if(st.count(it.first)){
                continue;
            }
            st.insert(it.first);
            vector<int>cur_path;
            cur_path.push_back(it.first);
            queue<int> q;
            q.push(it.first);
            while(!q.empty()){//使用广度优先搜索找当前具有邻接性的结点
                int cur_node=q.front();
                q.pop();
                for(int&n:mp[cur_node]){
                    if(st.count(n)){
                        continue;
                    }
                    st.insert(n);
                    q.push(n);
                    cur_path.push_back(n);
                }
            }
            paths.push_back(cur_path);
        }
        //将各个具有临界性的结点对应的字符找出，并排序，并重新存储到字符串中
        for(vector<int>&p:paths){
            vector<int> path(p.size());
            for(int i=0;i<p.size();++i){//找出对应的字符
                path[i]=s[p[i]];
            }
            sort(path.begin(),path.end());//排序
            sort(p.begin(),p.end());
            for(int i=0;i<p.size();++i){//重新压入字符串
                s[p[i]]=path[i];
            }
        }
        return s;
    }
};