leetcode 深度优先搜索与广度优先搜索 以及并查集

一、通俗解释：出处
深度优先可以这样想，一个人迷路，遇到很多分叉路口，他只有一个人，并且想走出去，所以只能一个个尝试，一条道路走到黑，发现到头了，然后再拐回去走刚才这条路的其他分叉路口，最后发现这条路的所有分叉路口走完了，选择另外一条路继续以上操作，直到所有的路都走过了。广度优先并不是这样，一个人迷路，但是他有技能（分身术）它遇到分叉路口，不是选一个走，而是分身多个人都试试，比如有A、B、C三个分叉路口，它A路走一步，紧接着B路也走一步，然后C路也赶紧走一步，步伐整齐统一，直到所有的路走过了。
广度优先并不是这样，一个人迷路，但是他有技能（分身术）它遇到分叉路口，不是选一个走，而是分身多个人都试试，比如有A、B、C三个分叉路口，它A路走一步，紧接着B路也走一步，然后C路也赶紧走一步，步伐整齐统一，直到所有的路走过了。
总结就是：一个往深处搜索，一个往四周搜索
并查集：
合并（Union）：把两个不相交的集合合并为一个集合。
查询（Find）：查询两个元素是否在同一个集合中。
二、特点
深度优先搜索（容易编写成递归），一般堆栈实现，通常解决连通问题
广度优先搜索，一般队列实现，通常解决最短路径问题

三、举例
LeetCode 547 省份数量
题目描述：
有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中 省份 的数量。

方法一：深度优先搜索dfs
代码如下：

class Solution {
public:
    int n;
    vector<bool>visited;
    int findCircleNum(vector<vector<int>>& isConnected) {
        n=isConnected.size();
        visited.resize(n);//记录每个城市是否被遍历过
        int res=0;
        for(int i=0;i<n;i++){
            if(!visited[i]){//如果这个城市没有被遍历过，那么就是一个新的互不连接的城市
                dfs(i,isConnected);//dfs找寻，与它相连的城市
                res++;
            }
        }
        return res;
    }
    void dfs(int i,vector<vector<int>>isConnected){
        visited[i]=true;//已经遍历过，设置为true
        for(int j=0;j<n;j++){
            if(isConnected[i][j]==1&&!visited[j]){//剪枝，如果有的城市已经遍历过，那么跳过
                dfs(j,isConnected);
            }
        }
    }
};

方法二：广度优先搜索bfs

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n=isConnected.size();
        vector<bool>visited(n);
        int res=0;
        queue<int>q;
        for(int i=0;i<n;i++){
            if(!visited){
                res++;
                q.push(i);
                visited[i]=true;
                while(q.size()){
                    int temp=q.front();
                    q.pop();
                    for(int j=0;j<n;j++){
                        if(isConnected[temp][j]==1&&!visited[j]){
                            visited[j]=true;
                            q.push(j);
                        }
                    }
                }
            }
        }
        return res;
    }
};

方法三：并查集union_find

class Solution {
public:
    vector<int>p;
    int find(int x){
        if(p[x]!=x) p[x]=find(p[x]);
        return p[x];
    }
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n=isConnected.size();
        //初始化
        for(int i=0;i<n;i++){
            p.push_back(i);
        }
        int cnt=n;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(isConnected[i][j]&&find(i)!=find(j)){
                    p[find(i)]=find(j);//集合合并
                    cnt--;
                }
            }
        }
        return cnt;
    }
};