图论(一):DFS,BFS,邻接链表,并查集

原创 2016年05月31日 20:43:44

本文总结了图的深度优先搜索,图的广度优先搜索,邻接链表和邻接矩阵的实现,并查集的实现。

0),预备知识
       
基础词汇:有向图,无向图,带权有向图,带权无向图,有向图中<Vi, Vj>:即Vi--->Vj,弧尾--->弧头,无向图中相邻记为(Vi, Vj),顶点有穷集合V+边的有穷集合E。
        图的两种实现方式:1,邻接矩阵:edge[n][n]表示有n个结点,数组内容为权值大小或者是否存在边(∞表示无边,权值或1表示有边,0表示结点到结点本身);
                                2,邻接链表:针对稀疏矩阵较适宜,为图的每个顶点都建立一个单链表,第i个单链表中保存与结点Vi所有相邻结点信息(无向图)或弧尾结点信息(有向图),以及边信息。


1),图的深度优先搜索(DFS)
        深度优先算法的主要思想是:首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点;当没有未访问过的顶点时,则回到上一个顶点,继续试探访问别的顶点,直到所有的顶点都被访问过。显然,深度优先遍历是沿着图的某一条分支遍历直到末端,然后回溯,再沿着另一条进行同样的遍历。
        例1:以下图为例,从结点1开始DFS,程序的算法思想是:在主函数中初始化连接矩阵,调用dfs(1) ---> 设置变量cnt,将cnt等于结点个数作为dfs递归的临界条件 ---> 设置标志mark[n],当当前访问结点的边指向的下一结点未被访问时,进行dfs调度访问(结点的相邻结点的访问顺序为标号由小到大的顺序)


/***先输入n个结点,m条边,之后输入无向图的m条边,之后对上图输出DFS遍历的结点顺序***/
#include <iostream>
#include <iomanip>
#define nmax 110
#define inf 999999999
using namespace std;
int n, m, cnt, edge[nmax][nmax], mark[nmax];//结点数,边数,计数值,邻接矩阵,结点访问标记
void dfs(int cur){
	cnt++;
	/***operation***/
	if(cnt == 1)
		cout << cur;
	else 
		cout << setw(3) << cur;
	/***operation***/
	if(cnt == n) return;
	else{
		int i;
		for(i = 1; i <= n; i++){
			if(edge[cur][i] == 1 && mark[i] == 0){
				mark[i] = 1;
				dfs(i);
			}
		}
		return;
	}

}

int main(){
	while(cin >> n >> m && n != 0){
		//初始化邻接矩阵
		int i, j;
		for(i = 1; i <= n; i++){
			for(j = 1; j <= n; j++){
				edge[i][j] = inf;
			}
			edge[i][i] = 0;
		}
		int a, b;
		while(m--){
			cin >> a >> b;
			edge[a][b] = edge[b][a] = 1;
		}
		//以dnf(1)为起点开始递归遍历
		memset(mark, 0, sizeof(mark));
		cnt = 0;
		mark[1] = 1;
		dfs(1);
		cout << endl;
	}
	return 0;
}
        程序运行结果:

        例2:下面是城市的地图,注意是单向图,求城市1到城市5的最短距离
        程序思路:从1号城市出发,可到达2号城市和5号城市,若按照1到n的顺序则先访问2号城市;访问完2号城市后,由于2号城市可到达的城市有3号和5号城市,我们访问3号城市;此后,3号城市可到达1号,4号城市,由于1号城市已被访问过,我们访问4号城市;4号城市又可到达5号城市,我们最后访问5号城市。但是,1->2->3->4->5并不一定是最短路径,我们需要撤除5号城市的访问标记,返回到4号城市,由于经由4号城市已访问过5号城市而又没有其他城市可访问;再返回到3号城市,经由3号城市访问过4号城市,则看看能否访问5号城市,不能则再返回到2号城市,这时2号城市有路径直达5号城市,即1->2->5.....如此折回再前进,直至找到所有1号城市能到达5号城市的路径,取其中的最小值。


/***先输入n个结点,m条边,之后输入有向图的m条边,边的前两元素表示起始结点,第三个值表权值,输出1号城市到n号城市的最短距离***/
/***算法的思路是访问所有的深度遍历路径,需要在深度遍历返回时将访问标志置0***/
#include <iostream>
#include <iomanip>
#define nmax 110
#define inf 999999999
using namespace std;
int n, m, minPath, edge[nmax][nmax], mark[nmax];//结点数,边数,最小路径,邻接矩阵,结点访问标记
void dfs(int cur, int dst){
	/***operation***/

	/***operation***/
	if(minPath < dst) return;//当前走过路径大于之前最短路径,没必要再走下去
	if(cur == n){//临界条件
		if(minPath > dst) minPath = dst;
		return;
	}
	else{
		int i;
		for(i = 1; i <= n; i++){
			if(edge[cur][i] != inf && edge[cur][i] != 0 && mark[i] == 0){
				mark[i] = 1;
				dfs(i, dst+edge[cur][i]);
				mark[i] = 0;			
			}
		}
		return;
	}
}

int main(){
	while(cin >> n >> m && n != 0){
		//初始化邻接矩阵
		int i, j;
		for(i = 1; i <= n; i++){
			for(j = 1; j <= n; j++){
				edge[i][j] = inf;
			}
			edge[i][i] = 0;
		}
		int a, b;
		while(m--){
			cin >> a >> b;
			cin >> edge[a][b];
		}
		//以dnf(1)为起点开始递归遍历
		memset(mark, 0, sizeof(mark));
		minPath = inf;
		mark[1] = 1;
		dfs(1, 0);
		cout << minPath << endl;
	}
	return 0;
}

        程序运行结果如下:



2),图的广度优先搜索(BFS)
          广度优先遍历的主要思想是:首先以一个未被访问过的顶点作为起始顶点,访问其所有相邻的顶点,然后对每个相邻的顶点,再访问它们相邻的未被访问过的顶点,直到所有顶点都被访问过,遍历结束。

        例1:根据1)例1中的无向图,输出其广度优先搜索顺序。
        程序主要思想:结点1入队 ---> while根据队列非空进行循环 ---> 出队并将相邻结点入队,此外需要设置计数值cnt,每次出队时加1。

/***先输入n个结点,m条边,之后输入无向图的m条边,边的两元素表示起始结点***/
#include <iostream>
#include <queue>
#include <iomanip>
using namespace std;
#define nmax 110
#define inf 999999999
queue<int> que;
int n, m, mark[nmax], edge[nmax][nmax], cnt;
int main(){
	while(cin >> n >> m && n != 0){
		int i, j;
		//初始化邻接链表
		for(i = 1; i <= n; i++){
			for(j = 1; j <= n; j++){
				edge[i][j] = inf;
			}
			edge[i][i] = 0;
		}
		int a, b;
		while(m--){
			cin >> a >> b;
			edge[a][b] = edge[b][a] = 1;
		}
		while(!que.empty()) que.pop();
		memset(mark, 0, sizeof(mark));
		//开始广度优先遍历
		int head;
		cnt = 0;
		mark[1] = 1;
		que.push(1);
		while(!que.empty()){
			head = que.front();
			que.pop();
			/***operation***/
			cnt++;
			if(cnt == 1)
				cout << head;
			else
				cout << setw(3) << head;
			/***operation***/
			for(i = 1; i <= n; i++){
				if(edge[head][i] == 1 && mark[i] == 0){
					mark[i] = 1;
					que.push(i);
				}
			}
		}
		cout << endl;
		if(cnt != n) cout << "The original image is not connected.\n";
	}
	return 0;
}
        程序运行结果如下:



        例2:如下图,需要坐飞机从1号城市到5号城市,求最小的转机次数


/***先输入n个结点,m条边,出发城市,终点城市,之后输入无向图的m条边,边的两元素表示起始结点***/
/***需要构建结点结构体Node,存放结点编号和遍历层数,每次for循环时该层数在上一层基础上加1***/
#include <iostream>
#include <queue>
using namespace std;
#define nmax 110
#define inf 999999999
struct Node{
	int node;
	int cnt;
};
queue<Node> que;
int m, n,  edge[nmax][nmax], mark[nmax], startNum, endNum;
int main(){
	while(cin >> n >> m >> startNum >> endNum && n != 0){
		bool tag = false;
		//初始化邻接矩阵
		int i, j;
		for(i = 1; i <= n; i++){
			for(j = 1; j <= n; j++){
				edge[i][j] = inf;
			}
			edge[i][i] = 0;
		}
		while(m--){
			cin >> i >> j;
			edge[i][j] = edge[j][i] = 1;
		}
		//开始广度优先遍历
		memset(mark, 0, sizeof(mark));
		while(!que.empty()) que.pop();
		Node tmp;
		tmp.node = startNum;
		tmp.cnt = 0;
		que.push(tmp);
		mark[tmp.node] = 1;
		while(!que.empty()){
			Node head = que.front();
			que.pop();
			Node temp;
			for(i = 1; i <= n; i++){
				if(edge[head.node][i] == 1 && mark[i] == 0){					
					temp.node = i;
					temp.cnt = head.cnt + 1;
					que.push(temp);//注意写在if语句里面
					mark[temp.node] = 1;
					if(temp.node == endNum){
						tag = true;
						cout << temp.cnt << endl;
						break;
					}
				}

			}
			if(tag)
				break;
		}
	}
	return 0;
}
        程序运行结果如下:




3),邻接链表和邻接矩阵的实现
       
邻接表由表头结点(结点信息)和表结点(边信息)两部分组成,其中图中每个顶点均对应一个存储在数组中的表头结点。以下为带权有向图:

        例1:邻接链表中每个顶点均对应一个存储在数组中的表头结点,为简化,每个邻接结点结构体只包含下一相邻结点编号和边权,使用标准模板vector编程实现。此外也可由邻接矩阵实现,上图实现如下:

/*****了解边信息结构体和邻接链表的实现,并在实现好基础上增加删除一些边,之后再用邻接矩阵实现,学习erase,push_back,setw的用法*****/
#include <iostream>
#include <iomanip>
#include <vector>
#define inf -1//设置无穷大为-1,表示无边
using namespace std;
int n;
//边信息,包含连接结点编号和边的权重
struct Edge{
	int adjNodeNum;
	int edgeWeight;
};
struct Node{//结点信息
	int nodeNum;
	char data;
}node[110];
vector<Edge> adjList[110]; //邻接链表,该图最多有110个结点
int adjMatrix[110][110];//邻接矩阵

void initAdjList(){
	int i;
	for(i = 0; i < n; i++) adjList[i].clear();//清空--->构建--->具体操作
	Edge tmp0[2], tmp1[2], tmp2, tmp3[3];
	tmp0[0].adjNodeNum = 1; tmp0[0].edgeWeight = 1;
	tmp0[1].adjNodeNum = 2; tmp0[1].edgeWeight = 4;
	node[0].data = 'A'; node[0].nodeNum = 0;
	adjList[0].push_back(tmp0[0]); adjList[0].push_back(tmp0[1]);
	tmp1[0].adjNodeNum = 2; tmp1[0].edgeWeight = 2;
	tmp1[1].adjNodeNum = 3; tmp1[1].edgeWeight = 9;
	node[1].data = 'B'; node[1].nodeNum = 1;
	adjList[1].push_back(tmp1[0]); adjList[1].push_back(tmp1[1]);
	tmp2.adjNodeNum = 3; tmp2.edgeWeight = 6;
	node[2].data = 'D'; node[2].nodeNum = 2;
	adjList[2].push_back(tmp2);
	tmp3[0].adjNodeNum = 0; tmp3[0].edgeWeight = 3;
	tmp3[1].adjNodeNum = 1; tmp3[1].edgeWeight = 5;
	tmp3[2].adjNodeNum = 2; tmp3[2].edgeWeight = 8;
	adjList[3].push_back(tmp3[0]); adjList[3].push_back(tmp3[1]); adjList[3].push_back(tmp3[2]);
	node[3].data = 'C'; node[3].nodeNum = 3;
}
void output(){
	int i, j;
	for(i = 0; i < n; i++){
		cout << node[i].nodeNum << setw(2) << node[i].data;
		for(j = 0; j < adjList[i].size(); j++){
			cout << setw(6) << adjList[i][j].adjNodeNum << setw(2) << adjList[i][j].edgeWeight;
		}
		cout << setw(9) << "NULL" << endl;
	}
}
void makeChange(){
	cout << "make some changes......:\n";
	Edge temp;
	temp.adjNodeNum = 3; temp.edgeWeight = 5;
	adjList[0].push_back(temp);//邻接表0中增加一个元素
	adjList[3].erase(adjList[3].begin()+1, adjList[3].begin()+3);//邻接表3中删除两个元素
}
void initMatrix(){
	int i, j;
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			adjMatrix[i][j] = inf;
		}
		adjMatrix[i][i] = 0;
	}
	adjMatrix[0][1] = 1; adjMatrix[0][2] = 4; adjMatrix[1][2] = 2;
	adjMatrix[1][3] = 9; adjMatrix[2][3] = 6; adjMatrix[3][0] = 3;
	adjMatrix[3][1] = 5; adjMatrix[3][2] = 8;
}
void output1(){
	int i, j;
	cout << "output the adjacency matrix:\n";
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			if(j == 0) cout << adjMatrix[i][j];
			else cout << setw(3) << adjMatrix[i][j];
		}
		cout << endl;
	}
}
int main(){
	n = 4;
	initAdjList();
	output();
	makeChange();
	output();
	initMatrix();
	output1();
	return 0;
}

        程序运行结果如下:



4),并查集的实现
       
并查集:用一棵树上的结点来表示在一个集合中的数字,如以下{1,2,3,4}和{5,6},再用每个结点中的内容表示其双亲结点,如Tree[N],则Tree[1] = -1, Tree[2] = 1, Tree[6] = 5......
如果想要合并这两棵树棵树,则可令Tree[5] = -1变为Tree[5] = 1。如下:

        对于,以下一种特殊情况,需要在查找树的根节点时,加以一定的约束与优化,将遍历过的元素的双亲结点设为根节点,如下:



        例1:并查集的实现

/****实现并查集的数组组成,找根节点,合并两个集合,压缩路径************************/
#include <iostream>
#include <iomanip>
using namespace std;

int Set[110];
int Tree[110];
//使用查找函数来寻找x所在树的根节点
int findRoot(int x){
	if(Tree[x] == -1) return x;
	else
		return findRoot(Tree[x]);
}
//使用压缩路径的查找函数来查找x所在树的根节点,只压缩x到root所查找的路径
int findRoot1(int x){
	if(Tree[x] == -1) return x;
	else{
		int tmp = findRoot1(Tree[x]);
		Tree[x] = tmp;
		return tmp;//层层返回
	}
}
//使用非递归方式
int findRoot_(int x){
	while(Tree[x] != -1) x = Tree[x];
	return x;
}
int findRoot_1(int x){
	int tmp = x;
	while(Tree[x] != -1) x = Tree[x];
	while(Tree[tmp] != -1) {tmp = Tree[tmp]; Tree[tmp] = x;}//tmp先保存父节点方便while循环,再对数组内容做改变
	return x;
}
int main(){
	int n1, n2;//集合1,2的元素个数
	cout << "Please input the number of set1 and the number of set2:\n";
	while(cin >> n1 >> n2){
		int i = 0, j;
		//输入集合1和2的数组表,第一行代表元素,第二行代表元素的双亲结点
		cout << "Please input set1(first line is  node, second line is its father node):\n"; 
		for(i = 0; i < n1; i++) cin >> Set[i];
		for(i = 0; i < n1; i++) cin >> Tree[Set[i]];
		cout << "Please input set2(first line is  node, second line is its father node):\n";
		for(i = n1 ; i < n1 + n2; i++) cin >> Set[i];
		for(i = n1 ; i < n1 + n2; i++) cin >> Tree[Set[i]];
		//输入集合1和集合2中的一个元素,找出各自的根节点
		cout << "Please input two nodes of the two sets (and output its root node):\n";
		int sub1, sub2;
		cin >> sub1 >> sub2;
		cout << "It's root node is: " << findRoot(sub1) << "   " << findRoot(sub2) << endl;
		//合并集合1和集合2,并显示
		cout << "Merge two trees:\n";
		Tree[findRoot1(sub2)] = findRoot1(sub1);
		for(i = 0; i < n1 + n2; i++) cout << setw(2) <<Set[i];
		cout << endl;
		for(i = 0; i < n1 + n2; i++) cout << setw(2) << Tree[Set[i]];
		cout << endl;
		cout << "Please input the number of set1 and the number of set2:\n";
	}
}

        程序运行结果如下:

        例2:畅通工程

/****输入城镇数n和道路数m,再输入每条道路连通的城镇(城镇从1开始编号),看至少需再修几条路使全部城镇连通;若输入n且n=0结束输入***********/
/****初始化n个并查集,此后每输入一条道路,就将关联的两个城镇加入同一并查集,最后由独立的并查集个数-1即为所求答案*********************/
#include <iostream>
using namespace std;
int Tree[1100];
int findRoot(int x){
	if(Tree[x] == -1) return x;
	else{
		int tmp = findRoot(Tree[x]);
		Tree[x] = tmp;
		return tmp;
	}
}

int main(){
	int n, m;
	while(cin >> n && n!= 0){
		cin >> m;
		int i;		
		for(i = 1; i <= n; i++)//初始化n个并查集
			Tree[i] = -1;		
		int a, b;
		for(i = m; i >= 1; i--){//处理m条道路,合并并查集
			cin >> a >> b;
			a = findRoot(a);
			b = findRoot(b);
			if(a != b) Tree[b] = a; //此处必须先进行比较,如果a,b相同,则会使根节点不为-1,导致并查集总数变少
		}		
		int count = 0;
		for(i = 1; i <= n; i++)//计算剩余独立的并查集
			if(Tree[i] == -1) ++count;
		cout << "Need to build the number of roads is: " << count - 1 << endl;
	}
}

        程序运行结果如下:

        例3:More Is Better

/***有1000 0000个小朋友,随机选择朋友关系,每次选中两个人,且朋友关系具有传递性,当选择m次后,输出最大朋友关系人数或1**********************/
/***思路与畅通工程类似,初始化并查集,对每次选择进行并查集合并,由于需要计算最大并查集元素个数,需要初始化每个sum[i]=1,每次合并都进行累加即可**/
/***先输入关系次数m,再依次输入这m组关系****/
#include <iostream>
using namespace std;
#define num 10000001
int Tree[num];
int Sum[num];
int findRoot(int x){
	if(Tree[x] == -1) return x;
	else{
		int tmp = findRoot(Tree[x]);
		Tree[x] = tmp;
		return tmp;
	}
}

int main(){
	int m;
	while(cin >> m && m != 0){
		int i;
		for(i = 1; i < num; i++) {Tree[i] = -1; Sum[i] = 1;}
		int a, b;
		while(m--){
			cin >> a >> b;
			a = findRoot(a);
			b = findRoot(b);
			if(a != b) {Tree[b] = a; Sum[a] += Sum[b];}
		}
		int max = 1;
		for(i = 1; i < num; i++)
			if(Sum[i] > max) max = Sum[i];
		cout << "Maximum number of friends is: " << max << endl;
	}
	return 0;
}

        程序运行结果如下:



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

一步一步学数据结构之n--n(图--邻接链表法实现)

在上篇文章已经介绍过图的内容,而且还介绍了用邻接矩阵实现的图,而在本篇文章,就说下用邻接链表实现的图。        常做的操作可以在上篇文章中查找,因为两中方法实现的图操作都是一模一样的。 代码总...

图(3)——邻接链表法

邻接链表法 基本思想:对图的每个顶点建立一个单链表,存储该顶点所有邻接顶点及其相关信息。每一个单链表设一个表头结点。 第i个单链表表示依附于顶点Vi的边(对有向图是以顶点Vi为头或尾的弧)...
  • luoweifu
  • luoweifu
  • 2013年07月08日 13:33
  • 15264

数据结构——图的链表实现(邻接表表示法)

图的链表实现 之前实现了图的数组实现 http://blog.csdn.net/cinmyheart/article/details/41370465 下图仅作示意性说明,和测试数据有点区别...

用邻接链表存储无向图和有向图

上一篇文章我们说到用邻接矩阵存储有向图和无向图,这种方法的有点是很直观的知道点与点之间的关系,查找的复杂度是为O(1)。但是这种存储方式同时存在着占用较多存储空间的问题, 邻接矩阵存储很好理解,但是...

图的邻接表和DFS遍历

邻接矩阵和邻接表的对比之前一篇文章我们学习了 图的邻接矩阵和DFS遍历, 邻接矩阵对于图来说是一种很不错的存储结构,但是也有特殊的情况,例如边数很少的时候。此时的邻接矩阵,只有(v0,v1)和(v1,...
  • jeffleo
  • jeffleo
  • 2016年11月24日 21:52
  • 1189

Uva 10129 - Play on Words 单词接龙 欧拉道路应用

跟Uva 10054很像,不过这题的单词是不能反向的,所以是有向图,判断欧拉道路。 关于欧拉道路(from Titanium大神): 判断有向图是否有欧拉路 1.判断有向图的基图(即有向图转化为...
  • hcbbt
  • hcbbt
  • 2013年07月13日 00:45
  • 2826

acm,基本图论算法及其解释

图论基本算法其实就6个,两个生成树,4个最短路径。   之前提到过的BFS算法,优点在于不用显式构建整个图,每次找到相邻即可,发现要到达的或者访问完毕即可退出。一般用于只求最短路。 技巧:设置数组,记...

图论 邻接链表存储 BFS DFS 拓扑排序 最小生成树 KRUSKAL PRIM

package Algorithms; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedLis...

HDU - 1198Farm Irrigation (BFS|DFS|并查集)

Farm IrrigationTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) ...

深度优先DFS和广度优先BFS,破圈法,拓扑序列,prim,克鲁斯卡尔等生成算法(需要用到并查集)迪杰斯特拉算法和弗洛伊德的总结

1.有向图:比较好 2.无向图是变态的有向图,需要注意度和节点之类的比如MST,最小生成树利用破圈法生成,关联的度为1的无向图节点肯定不是回路(不知道对不。。),1.找到图中的一个圈。2.删除其中的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:图论(一):DFS,BFS,邻接链表,并查集
举报原因:
原因补充:

(最多只允许输入30个字)