1202. 交换字符串中的元素(dfs, bfs, 并查集)

class solution {
public:
    vector<vector<int>>G;
    void G_init(vector<vector<int>>& pairs){
        for(auto p:pairs){
            G[p[0]].push_back(p[1]);
            G[p[1]].push_back(p[0]);
        }
    }
    void dfs(int i, vector<int>& conn){
        conn.push_back(i);
        for(auto u:G[i]){
            if(!vis[u]){
                vis[u]=1;
                dfs(u,conn);
            }
        }
    }
    string res;

    void match_sort(string & s, vector<int>& conn){
        sort(conn.begin(),conn.end());
        vector<char>match;
        for(auto ch:conn){
            match.push_back(s[ch]);
        }
        sort(match.begin(),match.end());
        int i=0;
        for(auto ch:conn){
            res[ch]=match[i];i++;
        } 

    }
    
    
    vector<int>vis;
    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        res=s;
        int n=s.size();
        G.resize(n);
        G_init(pairs);
        vis.resize(n,0);
        for(int i=0;i<n;i++){
            vector<int>conn;
            if(!vis[i]){
                vis[i]=1;
                dfs(i,conn);
            }
           match_sort(s,conn); 
        }
        return res;
    }
};

并查集

class Union{
    private:
    vector<int>parent,rank;
    // int n;
    public :
    Union(int n){
        rank.resize(n,1);
        parent.resize(n);
        for(int i=0;i<n;i++){
            parent[i]=i;
        }
    }

    int  find(int p){
        while(p!=parent[p]){
            parent[p]=parent[parent[p]];
            p=parent[p];
        }
        return p;
        }

    void unionElements(int p, int q){
        int Proot=find(p);
        int Qroot=find(q);
        if(Proot==Qroot) return ;
        if(rank[Proot]<rank[Qroot]){
            parent[Proot]=Qroot;
        }
        else if(rank[Proot]>rank[Qroot])
            parent[Qroot]=Proot;
        else {parent[Qroot]=Proot;
            rank[Proot]+=1;}
    }
};
class Solution {
public:

    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {

        int n=s.size();
        Union un=Union(n);
        for(auto & p:pairs){
            un.unionElements(p[0],p[1]);
        }
        unordered_map<int,vector<int>>mp;
        for(int i=0;i<n;i++){
            mp[un.find(i)].push_back(s[i]);
  
        }
        for(auto & [x,vec]:mp){
            sort(vec.begin(),vec.end(),greater<int>());
        }

        for(int i=0;i<s.length();i++){
            int x=un.find(i);
            s[i]=mp[x].back();
            mp[x].pop_back();
        }
        return s;
    }
};