UnionFind问题总结

UnionFind就是acm中常用的并查集...

并查集常用操作

另外补充一下STL常用操作

相关问题：

547. Friend Circles

纯裸题噢...

class Solution {
public:
    int root[210];
    bool v[210];

    void uf_init(int x)
    {
        for(int i=0;i<=x;i++)
            root[i]=i;
    }

    int uf_find(int x)
    {
        if(x!=root[x])
            root[x]=uf_find(root[x]);
        return root[x];
    }

    void uf_union(int x, int y)
    {
        int tx=uf_find(x);
        int ty=uf_find(y);
        if(tx!=ty)
            root[tx]=ty;
    }

    int findCircleNum(vector<vector<int>>& M) 
    {
        int kn=M.size();
        uf_init(kn);
        for(int i=0;i<kn;i++)
            for(int j=i+1;j<kn;j++)
                if(M[i][j])
                    uf_union(i,j);

        memset(v,0,sizeof(v));
        int cnt=0;
        for(int i=0;i<kn;i++)
            if(!v[uf_find(i)])
            {
                cnt++;
                v[uf_find(i)]=true;
            }
        return cnt;
    }
};

Graph Valid Tree 

（权限题做不了嘤嘤嘤）

684. Redundant Connection

并查集找无向图中的环，比较裸的题

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cstring>
#include <cstdio>
using namespace std;


class Solution {
public:
    int root[1010];

    void uf_init(int x)
    {
        for(int i=0;i<=x;i++)
            root[i]=i;
    }

    int uf_find(int x)
    {
        if(x!=root[x])
            root[x]=uf_find(root[x]);
        return root[x];
    }

    void uf_union(int x, int y)
    {
        int tx=uf_find(x);
        int ty=uf_find(y);
        if(tx!=ty)
            root[tx]=ty;
    }

    vector<int> findRedundantConnection(vector<vector<int>>& edges) 
    {
        int k=edges.size();
        int kx,ky;
        uf_init(k);
        for(int i=0;i<k;i++)
        {
            kx=edges[i][0];
            ky=edges[i][1];
            if(uf_find(kx)!=uf_find(ky))
                uf_union(kx,ky);
            else
                return(edges[i]);
        }
    }
};


int main()
{
    Solution sl;
    return 0;
}

685. Redundant Connection II = 改成了有向图，复杂了许多......

不会做嘤嘤嘤

721. Accounts Merge

比较裸的并查集。将email重复的两个账户union一下，最后再输出每个集合

class Solution:
    def uf_init(self,x):
        self.root=[0 for i in range(x+10)]
        for i in range(x):
            self.root[i]=i

    def uf_find(self, x):
        if(x!=self.root[x]):
            self.root[x]=self.uf_find(self.root[x])
        return self.root[x]

    def uf_union(self, x, y):
        tx=self.uf_find(x)
        ty=self.uf_find(y)
        if(tx!=ty):
            self.root[tx]=ty

    def similar(self, acc1, acc2):
        res=0
        if(acc1[0]!=acc2[0]):
            return res
        for i in acc1[1:]:
            for j in acc2[1:]:
                if(i==j):
                    res=1
        return res

    def accountsMerge(self, accounts):
        """
        :type accounts: List[List[str]]
        :rtype: List[List[str]]
        """
        ka=len(accounts)
        print(ka)
        self.uf_init(ka)
        
        hsh={}
        for i in range(ka):
            for j in range(len(accounts[i])-1):
                if(hsh.get(accounts[i][j+1])!=None):
                    dx=hsh[accounts[i][j+1]]
                    uf_union(dx,i)
                else:
                    hsh[accounts[i][j+1]]=i


        dct=[set() for i in range(ka)]
        lbl=["" for i in range(ka)]
        for i in range(ka):
            ui=self.uf_find(i)
            lbl[ui]=accounts[i][0]
            for j in range(len(accounts[i])-1):
                dct[ui].add(accounts[i][j+1])

        ans=[]
        for i in range(ka):
            if(lbl[i]!=""):
                tmp=[]
                for j in dct[i]:
                    tmp.append(j)
                tmp.sort()
                tmp=[lbl[i]]+tmp
                ans.append(tmp)

        return ans

注意用hashmap优化掉两重循环的方法，比较常用

        for i in range(0,ka):
            for j in range(i+1,ka):
                if(self.similar(accounts[i],accounts[j])):
                    self.uf_union(i,j)

        hsh={}
        for i in range(ka):
            for j in range(len(accounts[i])-1):
                if(hsh.get(accounts[i][j+1])!=None):
                    dx=hsh[accounts[i][j+1]]
                    uf_union(dx,i)
                else:
                    hsh[accounts[i][j+1]]=i

399. Evaluate Division

一开始想了半天是不是数学题...其实在纸上画画可以发现，这是一个图论题......

这样就转化成了求图中每对节点最短路问题，这时小学生会选择用Floyd算法，时间复杂度O(N^3)

#define GMAX 0x7f7f7f7f
// initiate double with maxium value:
// https://blog.csdn.net/popoqqq/article/details/38926889

class Solution {
public:
    double graph[1010][1010];

    vector<double> calcEquation(vector<pair<string, string>> equations, 
                                vector<double>& values, 
                                vector<pair<string, string>> queries) 
    {
        memset(graph,0x7f,sizeof(graph));
        cout<<graph[4][3]<<endl;
        int kl=values.size(), kq=queries.size();
        map<string,int> dict;
        int dcnt=0,dx,dy;
        for(int i=0;i<kl;i++)
        {
            if(dict.find(equations[i].first)==dict.end())
            {
                dcnt++;
                dict.insert(pair<string, int>(equations[i].first, dcnt));
            }
            if(dict.find(equations[i].second)==dict.end())
            {
                dcnt++;
                dict.insert(pair<string, int>(equations[i].second, dcnt));
            }
            dx=dict[equations[i].first];
            dy=dict[equations[i].second];
            graph[dx][dy]=values[i];
            graph[dy][dx]=1/values[i];
            cout<<dx<<"--"<<dy<<" "<<values[i]<<endl;
        }

        for(int i=1;i<=dcnt;i++)
            graph[i][i]=1;
        for(int k=1;k<=dcnt;k++)
            for(int i=1;i<=dcnt;i++)
                for(int j=1;j<=dcnt;j++)
                    if(graph[i][k]<GMAX && graph[k][j]<GMAX)
                        graph[i][j]=min(graph[i][j],graph[i][k]*graph[k][j]);
        
        vector<double> ans;
        string sx,sy;
        for(int i=0;i<kq;i++)
        {
            sx=queries[i].first;
            sy=queries[i].second;
            if(dict.find(sx)==dict.end() || dict.find(sy)==dict.end())
                ans.push_back(-1.0);
            else
            {
                dx=dict[sx];
                dy=dict[sy];
                if(graph[dx][dy]<GMAX)
                    ans.push_back(graph[dx][dy]);
                else
                    ans.push_back(-1.0);
                cout<<dx<<"__"<<dy<<endl;
            }
        }

        return ans;
    }
};

但大学生们会用并查集来解呢

balabala