UnionFind问题总结

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

并查集常用操作

另外补充一下STL常用操作

相关问题：

547. Friend Circles

纯裸题噢...

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

     void uf_init(int x)
     {
         for(int i=;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=;i<kn;i++)
             for(int j=i+;j<kn;j++)
                 if(M[i][j])
                     uf_union(i,j);

         memset(v,,sizeof(v));
         int cnt=;
         for(int i=;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[];

     void uf_init(int x)
     {
         for(int i=;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=;i<k;i++)
         {
             kx=edges[i][];
             ky=edges[i][];
             if(uf_find(kx)!=uf_find(ky))
                 uf_union(kx,ky);
             else
                 return(edges[i]);
         }
     }
 };

 int main()
 {
     Solution sl;
     return ;
 }

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[][];

     vector<double> calcEquation(vector<pair<string, string>> equations,
                                 vector<double>& values,
                                 vector<pair<string, string>> queries)
     {
         memset(graph,0x7f,sizeof(graph));
         cout<<graph[][]<<endl;
         int kl=values.size(), kq=queries.size();
         map<string,int> dict;
         int dcnt=,dx,dy;
         for(int i=;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]=/values[i];
             cout<<dx<<"--"<<dy<<" "<<values[i]<<endl;
         }

         for(int i=;i<=dcnt;i++)
             graph[i][i]=;
         for(int k=;k<=dcnt;k++)
             for(int i=;i<=dcnt;i++)
                 for(int j=;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=;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