LeetCode 1202交换字符串中的元素

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

理解及思路

给出的pairs中的两个点具有传递性，即1和2能交换，2和3能交换，那么1,2,3就都能交换，所以我们只需要把能交换的点放在一起，再进行排序就可以了。
我们用并查集来存储点之间的关系，然后用哈希表分别存储相同父结点的点。再按位置输出即可。
因为用C实现哈希实在麻烦，这边就当学习C++ 和 Java的语法了。
一些数据结构不会用还是不行的。
代码几乎是抄官方题解的，注释是自己做的，希望对大家有帮助

C++AC代码

class DisjointSetUnion  {
private:
    vector<int> f,rank;//f存储父结点情况，rank存储树的高度。
    int n;
public:
    DisjointSetUnion(int _n)    {
        n = _n;
        rank.resize(n,1);//调整容器的大小为n，扩容后每个元素的值为1
        f.resize(n);//调整容器的大小为n
        for(int i = 0; i < n; i++)  {
            f[i] = i;
        }
    }

    int find(int x) {//写法比较简单。其实可以加路径压缩优化，不过已经有按秩合并，也不会太慢。换成注释里的代码可以少10几毫秒
        //if(f[x] == x)   return x;
        //f[x] = find(f[x]);
        //return f[x];
        return f[x] == x? x:find(f[x]);
    }    

    void unionSet(int x, int y)   {//比起普通的Union，写了个按秩合并。
        int fx = find(x), fy = find(y);
        if(fx == fy)
            return;
        if(rank[fx] < rank[fy]) {
            swap(fx,fy);//交换两个同类型向量的数据。
        }
        //维护fx 和 fy的高度。
        rank[fx] += rank[fy];
        //这一步的前提是rank[fx] >= rank[fy],要把高度小的根连到高度大的根上。
        f[fy] = fx;
    }
};




class Solution {
public:
    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        DisjointSetUnion dsu(s.length());
        for(auto& it : pairs)   {//增强for遍历。如果是一维数组，就写for(auto it : pairs),不需要加取地址符
            dsu.unionSet(it[0],it[1]);
        }
        unordered_map<int, vector<int> > mp;//创建一个哈希表
        for(int i = 0; i < s.length(); i++) {
            mp[dsu.find(i)].emplace_back(s[i]);//在mp(哈希表)下加入元素
        }
        for(auto& [x,vec] : mp) {//哈希表也能用增强for啊。
            sort(vec.begin(),vec.end(),greater<int>());//按字典序排序哈希表中的字母。greater是降序排序。默认是升序（less）
        }
        for(int i = 0; i < s.length(); i++) {
            int x = dsu.find(i);
            s[i] = mp[x].back();//最后一个元素的值
            mp[x].pop_back();//弹出最后一个元素。
        }
        return s;
    }
};

Java AC代码

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;

class Solution {
    public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
        if(pairs.size() == 0)   {//如果索引对数为0，就不能交换。
            return s;
        }
        int len = s.length();
        UnionFind unionFind = new UnionFind(len);//创建对象，便于调用。
        for(List<Integer> pair : pairs)  {//增强for遍历，与C++不同，Java没有指针的概念，不需要加&，只要在这个对象下调用get方法就好。
            int index1 = pair.get(0);
            int index2 = pair.get(1);
            unionFind.union(index1,index2);
        }

        char[] charArray = s.toCharArray();//把String转换为char型数组
        //创建一个哈希表数组
        Map<Integer,PriorityQueue<Character>> hashMap = new HashMap<>(len);//因为要按照字典序排序，所以用到数据结构是优先队列
        for(int i = 0; i < len; i++)    {
            int root = unionFind.find(i);//根据父结点，将元素加入不同的哈希表
            if(hashMap.containsKey(root))   {//如果该键存在，则直接加入元素
                hashMap.get(root).offer(charArray[i]);
            }
            else    {//否则先创建键，再加入元素。
                hashMap.computeIfAbsent(root, key->new PriorityQueue<>()).offer(charArray[i]);
            }
        }
        StringBuilder stringBuilder = new StringBuilder();//创建可变字符串类以存储排序好的结果。
        for(int i = 0; i < len; i++)    {
            int root = unionFind.find(i);
            stringBuilder.append(hashMap.get(root).poll());
        }
        return stringBuilder.toString();//转换为String返回程序
    }
    private class UnionFind {//这个类也可以写到Solution外面，但是要改成public
    private int[] parent;//存储父结点情况

    private int[] rank;//树的高度

    public UnionFind(int n) {//初始化parent和rank数组
        this.parent = new int[n];
        this.rank = new int[n];
        for(int i = 0; i < n; i++)  {
            this.parent[i] = i;
            this.rank[i] = 1;
        }
    }

    public void union(int x, int y) {//将x 和 y加入并查集,这里用了按秩合并来优化
        int rootX = find(x);
        int rootY = find(y);
        if(rootX == rootY)  
            return;
        if(rank[rootX] == rank[rootY])  {
            parent[rootX] = rootY;
            rank[rootX] = rootY;

        }
        else if(rank[rootX] < rank[rootY])  {
            parent[rootX] = rootY;
        }
        else{
            parent[rootY] = rootX;
        }
    }

    public int find(int x)  {//找到这个点所对应的父结点，这里用了路径压缩来优化。
        if(x != parent[x])  {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
}
}