参考博客：

https://blog.csdn.net/jinzk123/article/details/52231527

https://blog.csdn.net/qq_40998706/article/details/86697221

一 .   DFS+标记

(求连通分量个数)

题目描述  在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。如果图中任意两个顶点之间都连通，则称该图为连通图， 否则，称该图为非连通图，则其中的极大连通子图称为连通分量，这里所谓的极大是指子图中包含的顶点个数极大。 例如：一个无向图有5个顶点，1-3-5是连通的，2是连通的，4是连通的，则这个无向图有3个连通分量。

输入  第一行是一个整数T，表示有T组测试样例(0 < T <= 50)。每个测试样例开始一行包括两个整数N，M，(0 < N <= 20,0 <= M <= 200) 分别代表N个顶点，和M条边。下面的M行，每行有两个整数u，v，顶点u和顶点v相连。

输出  每行一个整数，连通分量个数。 示例输入

2 3 1 1 2 3 2 3 2 1 2

示例输出

2 1

#include

#include

#include

int mp[100][100];     //此处当稀疏图处理，建立邻接矩阵

int vis[100];

//传入起点和所有点的个数

void dfs(int x,int n)         //dfs搜索，每搜索到一个点处标记已经遍历过，继续dfs直到无点可连

{                             //最终所有与x有路相连的点都被遍历到并标记

vis[x]=1;

for(int i=1;i<=n;i++)

{

if(!vis[i]&&mp[x][i])    //没有遍历过该点(v)并且两点(u-v)间有路相连(无向图)

{

dfs(i,n);             //把该点(v)当“起点”继续dfs

}

}

}

int main()

{

int T,n,m,u,v,count;

scanf("%d",&T);

while(T--)

{  count=0;

scanf("%d%d",&n,&m);

memset(mp,0,sizeof(mp));

memset(vis,0,sizeof(vis));

for(int i=0;i<=m-1;i++)

{

scanf("%d%d",&u,&v);

mp[u][v]=mp[v][u]=1;    //建立邻接矩阵

}

for(int i=1;i<=n;i++)       //对n个点进行dfs搜索+标记

{

if(!vis[i])

{

dfs(i,n);//相当产生一个连通分量后返回到此，然后对其进行计数，最终得有几个连通分量

count++;//每有一个新的未被标记的点就有了一个新的分支

}

}

printf("%d\n",count);

}

return 0;

}

二. 用栈实现DFS

(染色区分出连通分量，判断两点是否连通)

问题描述请编写一个程序，输入SNS的朋友关系，判断从指定人物出发能否通过双向朋友链抵达人物。输入： 第1行输入代表SNS用户数的整数n以及代表朋友关系数的m，用空格隔开。SNS各用户的ID分别为0到n-1。接下来的m行输入朋友关系，每个朋友关系占1行。1个朋友关系包含s、t这两个整数，表示s和t为朋友。s、t输入时用空格隔开。紧接下来的1行输入问题数q。再接下来的q行输入问题。各问题均为用空格隔开的2个整数s、t，表示从s出发能否抵达t？

输出： 如果从s出发能抵达t就输出yes，否则输出no，每个问题的回答占1行。

限制：2 ≤ n ≤ 1000000 ≤ m ≤ 1000001 ≤ q ≤ 10000

输入示例10 9

0 1

0 2

3 4

5 7

5 6

6 7

6 8

7 8

8 9

3

0 1

5 9

1 3

输出示例

yes

yes

no

讲解：

这是一个求图连通分量(Connected Components)的问题。对于一个连通性未知的图G，其极大联通子图即为G的连通分量。在G的连通子图中，如果包含G’的图只有G’，那么G’就是G的极大连通子图。 连通分量可以通过深度优先搜索和广度优先搜索来寻找。在本题中，我们需要对顶点数和边数都很多的大规模图进行深度优先或广度优先搜索，所以不能采用消耗内存空间为O(n^2)的邻接矩阵。于是我们用邻接表来表示图。 邻接表适合边数较少的稀疏图。在无权值有向图的邻接表中，各项点都对应着一个相邻顶点的编号列表。如果换作无向图，那么只要u的列表中包含v，v的列表中也就一定包含u。

vector G[100];//表示有100个顶点的图的邻接表

......................................

G[u].push_back(u);//从顶点u向顶点v画边

................................................

//搜索与顶点u相邻的顶点v

for(int i = 0; i < G[u].size(); i++){

int v = G[u][i];

....................

}

求图的连通分量时，需要以未访问的顶点为起点循环执行深度优先搜索(或广度优先搜索)。只要在此过程中给每轮搜索到的顶点分配不同的编号(颜色)，我们就可以用O(1)来判断指定的两个顶点是否属于同一组(颜色)了。 使用邻接表的深度优先搜索和广度优先搜索都需要对每个顶点各访问一次，同时还需对邻接表中的顶点(边)也逐一进行访问，因此算法复杂度为O(|V|+|E|)。 邻接表表示法的优点： 只需与边数成正比的内存空间。 邻接表表示法的缺点： 需要消耗O(n)来搜索邻接表。不过大部分算法(如BFS、DFS等)只需对特定顶点的相邻顶点进行一次遍历即可满足需求，因此影响并不大。 难以有效删除边。

#include

#include

#include

using namespace std;

static const int MAX = 100000;

static const int NIL = -1;

int n;

vector G[MAX];

int color[MAX];

void dfs(int r, int c){

stack S;

S.push(r);

color[r] = c;

while( !S.empty() ){

int u = S.top(); S.pop();

for(int i = 0; i < G[u].size(); i++){

int v = G[u][i];

if(color[v] == NIL) {

color[v] = c;

S.push(v);

}

}

}

}

void assignColor(){

int id = 1;

for(int i = 0; i < n; i++) color[i] = NIL;

for(int u = 0; u < n; u++){

if(color[u] == NIL) dfs(u, id++);

}

}

int main(){

int s, t, m, q;

cin>>n>>m;

for(int i = 0; i < m; i++){

cin>>s>>t;

G[s].push_back(t);

G[t].push_back(s);

}

assignColor();

cin>>q;

for(int i = 0; i < q; i++){

cin>>s>>t;

if(color[s] == color[t]){

cout<

} else {

cout<

}

}

return 0;

}

按(dfs+标记   同样可求此题)  照着第一篇代码改一小部分后如下

#include      //dfs    判断两点是否能联通

using namespace std;

int mp[100][100];

int vis[100],color[100];

void dfs(int s,int n,int cnt)

{

vis[s]=1;

color[s]=cnt;

for(int i=0;i

{

if(!vis[i]&&mp[s][i])

dfs(i,n,cnt);

}

}

int main()

{

int n,m,s,t,q;

int cnt=0;

memset(vis,0,sizeof(vis));

memset(mp,0,sizeof(mp));

cin>>n>>m;

for(int i=0;i

{

cin>>s>>t;

mp[s][t]=mp[t][s]=1;

}

for(int i=0;i

{

if(!vis[i])

{

dfs(i,n,cnt);

cnt++;

}

}

cin>>q;

for(int i=0;i

{

cin>>s>>t;

if(color[s]==color[t])

cout<

else

cout<

}

return 0;

}