力扣323.无向图中连通分量的数目（dfs/bfs）

这道题按理说是一眼并查集的，不过深搜广搜也可以做

bfs：

失败版，这是我最开始写出来的bfs代码，不过超时了，原因应该是遍历edges太费时了，因为edges存的时候是无序的，要找到我需要的节点就要遍历整个容器

class Solution {
public:
    int countComponents(int n, vector<vector<int>>& edges) {
        int ans=0;
        vis=vector<int>(n,0);
        queue<int> q;
        for(int i=0;i<n;i++){
            if(vis[i]==0){//判断成功一次就代表有一组连通的图，所以数量要加1
                vis[i]=1;//从该节点出发，进行bfs
                q.push(i);
                while(!q.empty()){//这都是bfs的公式代码了
                    int e=q.front();
                    q.pop();
                    for(auto edge:edges){
                        if(edge[0]==e&&vis[edge[1]]==0||edge[1]==e&&vis[edge[0]]==0){
                            int d=edge[0]==e?edge[1]:edge[0];
                            vis[d]=1;//标记该连通图的所有节点
                            q.push(d);
                        }
                    }
                }
                ans++;
            }
        }
        return ans;
    }
private:
    vector<int> vis;
};

所以改进的话就再建个邻接矩阵，这样找临边就方便许多。

int countComponents(int n, vector<vector<int>>& edges) {
        //第一步，构建图
        vector<vector<int> > adj;
        adj.resize(n);
        int m=edges.size();
        for(int i=0;i<m;i++)
        {
            adj[edges[i][0]].push_back(edges[i][1]);
            adj[edges[i][1]].push_back(edges[i][0]);
        }
        //第二步，bfs遍历
        int res=0;
        vector<bool> vis(n,false);
        for(int i=0;i<n;i++)
        {
            if(!vis[i])
            {
                queue<int> que;
                que.push(i);
                vis[i]=true;//******
                while(!que.empty()){
                    int temp=que.front();
                    que.pop();
                    for(auto v:adj[temp]) {
                        if(!vis[v]){
                            que.push(v);
                            vis[v]=true;//****
                        }
                    }
                }
                res++;
            }
        }
        return res;
}

dfs：

所以dfs也得加邻接矩阵

class Solution {
public:
    int countComponents(int n, vector<vector<int>>& edges) {
        if(n==0) return 0;
        int components=0;
        vector<int> visited(n,0);
        vector<int> adjList[n];
        for(int i=0;i<edges.size();i++){
            adjList[edges[i][0]].push_back(edges[i][1]);
            adjList[edges[i][1]].push_back(edges[i][0]);
        }
        for(int i=0;i<n;i++){
            if(visited[i]==0){
                components++;
                dfs(adjList,visited,i);
            }
        }
        return components;
    }
private:
    void dfs(vector<int> adjList[],vector<int> &visited,int src){
        //dfs也是公式代码，真是公公又式式啊
        visited[src]=1;
        for(int i=0;i<adjList[src].size();i++){
            if(visited[adjList[src][i]]==0)
                dfs(adjList,visited,adjList[src][i]);
        }
    }
};