图论算法

1.广度优先搜索（BFS）breadth-first search

#include<iostream>
#include<queue>
using namespace std;
const int N=100;
const int MAX=100000; //可用系统的INT_MAX最大int数宏定义
bool visit[N];
int d[N],path[N];
struct Node{
	int v;
	Node* next;
	Node(int x):v(x),next(0){}//参数初始化表
};
struct Graph{
	int E,V;
	Node* Adj[N];//邻接表
};
//无向图
void CreateGraph(Graph &G){
	cin>>G.V>>G.E;
	for(int i=0;i<G.V;++i) //顶点数小于N
		G.Adj[i]=NULL;
	for(int i=0;i<G.E;++i){//边数
	
		int u,v;
		cin>>u>>v;
		Node* p=new Node(u);
		p->next=G.Adj[v];
		G.Adj[v]=p;
		p=new Node(v);
		p->next=G.Adj[u];
		G.Adj[u]=p; //顶点v和u邻接，在无向图中一条边在两个节点的邻接表都存在。从头节点处插入新节点，同时每次保持G.Adj[v]和G.Adj[u]都存放各个邻接表的中的头节点。

	}
}
void BFS(Graph &G,int s){
		for(int i=0;i<G.V;++i){
		visit[i]=false;
		d[i]=MAX;
		path[i]=-1;
		}
	queue<int> Q;
	d[s]=0;
	Q.push(s);
	while(!Q.empty()){
		int u=Q.front();
		Q.pop();
		visit[u]=true;
	for(Node* p=G.Adj[u];p!=NULL;p=p->next){	
		if(d[p->v]==MAX){
			d[p->v]=d[u]+1;
			path[p->v]=u;
			Q.push(p->v);
		}
	}
}
}
void PrintPath(Graph &G,int s, int v){
	if(v==s)
		cout<<s;
	else
	{
	PrintPath(G,s,path[v]);
	cout<<v;
	}

}
	
int main(){
	Graph G;
	CreateGraph(G);
	BFS(G,1);
    PrintPath(G,1,3);
	return 0;
}

2.深度优先搜索（DFS）depth-first search

#include<iostream>
using namespace std;
const int N=100;
bool visit[N];
int path[N],f[N],l[N],time;
struct Node{
	int v;
	Node* next;
	Node(int x):v(x),next(0){}//参数初始化表
};
struct Graph{
	int E,V;
	Node* Adj[N];//邻接表
};
//有向图
void CreateGraph(Graph &G){
	cin>>G.V>>G.E;
	for(int i=0;i<G.V;++i) //顶点数小于N
		G.Adj[i]=NULL;
	for(int i=0;i<G.E;++i){//边数
	
		int u,v;
		cin>>u>>v;
		Node* p=new Node(v);
		p->next=G.Adj[u];
		G.Adj[u]=p; //顶点u邻接v，这里邻接表的输出与输入是相反的。先输入的放在链表的后面，从尾部开始链接，一直到头部。
	}
}
void DFSVist(Graph &G, int v){//递归遍历每一分支，直到遇到终止条件。
	f[v]=++time;
	visit[v]=true;
	for(Node* p=G.Adj[v];p;p=p->next){	
		int u=p->v;
		if(!visit[u]){
			DFSVist(G,u);
		    path[u]=v; 
		}
	}
	l[v]=++time;
}
void DFS(Graph &G){

	for(int i=0;i<G.V;++i){	
		visit[i]=false;
		path[i]=-1;
	}
	time=0;
	for(int i=0;i<G.V;++i)
		if(!visit[i])
			DFSVist(G,i);
}

int main(){
	Graph G;
	CreateGraph(G);
	DFS(G);
	for(int i=0;i<G.V;i++)
		cout<<f[i]<<' '<<l[i]<<endl;
	return 0;
}

DFS算法的应用----------》

深度优先和广度优先各有各的优缺点：

1）广优的话，占内存多，能找到最优解，必须遍历所有分枝. 广优的一个应用就是迪科斯彻单元最短路径算法.

2）深优的话，占内存少，能找到最优解（一定条件下），但能很快找到接近解（优点），可能不必遍历所有分枝（也就是速度快）, 深优的一个应用就是连连看游戏.

两种算法的不同点。广度优先搜索，适用于所有情况下的搜索，但是深度优先搜索不一定能适用于所有情况下的搜索。因为由于一个有解的问题树可能含有无穷分枝，深度优先搜索如果误入无穷分枝（即深度无限），则不可能找到目标节点。所以，深度优先搜索策略是不完备的。

广度优先搜索适用范围：在未知树深度情况下，用这种算法很保险和安全。在树体系相对小不庞大的时候，广度优先也会更好些。

深度优先搜索适用范围：刚才说了深度优先搜索又自己的缺陷，但是并不代表深度优先搜索没有自己的价值。在树深度已知情况下，并且树体系相当庞大时，深度优先搜索往往会比广度优先搜索优秀，因为比如8*8的马踏棋盘中，如果用广度搜索，必须要记录所有节点的信息，这个存储量一般电脑是达不到的。然而如果用深度优先搜索的时候却能在一个棋盘被判定出来后释放之前的节点内存。