给你一个字符串 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"
提示:
<= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s
中只含有小写英文字母
解答
由于不限制交换次数,因此pairs
中相连索引处的字符可以任意交换位置,于是可以用并查集来维护连通的索引集合,依次将连通索引集合内的字符排序并放置在相应位置即可。由于可能有多个连通分量,因此使用哈希表来记录不同连通分量:
class DisjointSetUnion{
vector<int> parent;
public:
DisjointSetUnion(int n){
for(int i = 0; i < n; i++){
parent.push_back(i);
}
}
int find(int x){
if(x != parent[x]){
int temp = find(parent[x]);
parent[x] = temp;
}
return parent[x];
}
void merge(int x, int y){
int p_x = find(x);
int p_y = find(y);
if(p_x != p_y){
parent[p_x] = p_y;
}
}
};
class Solution {
public:
string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
// 构建并查集,记录连通的索引
int n = s.size();
DisjointSetUnion dsu(n);
for(const auto& p : pairs){
dsu.merge(p[0], p[1]);
}
// 将连通分量存储在表中,键为根索引,值为所有连通的索引
unordered_map<int, set<int>> map;
for(int i = 0; i < n; i++){
map[dsu.find(i)].insert(i);
}
// 依次对连通的索引进行排序并赋值
for(const auto& key_value : map){
string temp;
for(const auto& c : key_value.second){
temp += s[c];
}
sort(temp.begin(), temp.end());
int i = 0;
// set 是有序的,所以直接将排好序的字符依次放置在相应索引处
for(const auto& index : key_value.second){
s[index] = temp[i++];
}
}
return s;
}
};