简述dfs,bfs,Dijkstra思想及区别

在做pat的时候，用dfs写了一道题的解超时，看别人的解法时，发现别人用了Dijkstra算法，瞬间自己就混乱了，因为之前也看过Dijkstra，bfs算法，但是当时居然都傻傻分不清楚了，所以决定写一篇总结一下。

一：广度优先算法(BFS)

        先搜索邻居，搜完邻居再搜邻居的邻居。

其中俩个思想：1.双端队列不为空则循环

                            2.将未访问的邻接点压入双端链表后面，然后从前面取出并访问（这样就做到了广度优先）

图的解释：

                         0

                   1          2

             3        4   5        6

这个是二叉树的例子，

这里如果是广度优先的话，访问的顺序依次是0123456.

代码如下：

#include<iostream> 
#include<string>
#include<vector>
#include<deque>
#include <limits.h>
using namespace std;

int Graph[7][7] = { 
INT_MAX, 1, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
1, INT_MAX, INT_MAX, 1, 1,INT_MAX, INT_MAX ,
1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,1,1,
INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX };

void bfs();
deque<int> a;
int visited[7] = { 0 };
int main(void)
{
	ios::sync_with_stdio(false);
	
	
	bfs();
	return 0;
}
void bfs()
{
	a.push_back(0);                           //将原点压入堆后
	while (!a.empty())
	{
		int u = a.front();                         //取出堆前的一个元素
		//cout << "u: " << u;
		for (int i = 0; i < 7; i++)
		{
			if (Graph[u][i] != INT_MAX&&!visited[i])            //找到他的邻接点
			{
				
				a.push_back(i);                        //压入堆后
			}
		}
		visited[u] = 1;                                //标记为访问
		cout << u;                             //输出
		a.pop_front();                // 将堆前元素压出
	}
	
}

二：深度优先算法（DFS）

    我这里介绍下递归思想来写：

     1.先找到出发点

     2.依次对找其所有未访问的邻接点做dfs（仔细想想，这里，未访问完邻居继续做dfs，这样就做到了深度优先，是不是？）

这里贴一个树的深度优先搜索树的例子

这个树很简单：

                         0

                   1          2

             3        4   5        6

是一个二叉树。

如果是深度优先算法来搜，则搜索顺序应该为：0134256

这里贴出代码

#include<iostream> 
#include<string>
#include<vector>
#include <limits.h>
using namespace std;
int Graph[7][7] = { 
INT_MAX, 1, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
1, INT_MAX, INT_MAX, 1, 1,INT_MAX, INT_MAX ,
1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,1,1,
INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX ,
INT_MAX, INT_MAX, 1, INT_MAX, INT_MAX, INT_MAX, INT_MAX };

void dfs(int number);
int visited[7] = { 0 };
int main(void)
{
	ios::sync_with_stdio(false);
	
	dfs(0);
	return 0;
}
void dfs(int number)
{
	visited[number] = 1;             //访问number
	cout << number << " ";            //输出number
	for (int i = 0; i < 7; i++)
	{
		if (!visited[i]&&Graph[number][i]!=INT_MAX)     //查找number的未访问过的邻接点
		{
			dfs(i);                                  
		}
	}
	
	//visited[number] = 0;     //这个例子不用回朔答案也是对的，先不解释
}

三.Dijkstra算法

    1.找出未访问过的到原点距离最小的顶点并标记为访问

    2.循环上个过程直到所有点都被访问完

    开始自己也不知道广度优先算法与Dijkstra算法的区别，广度优先是先将未访问的邻居压入队列，再将未访问邻居的未访问过的邻居压入队列再依次访问，Dijkstra是在剩余的未访问过的顶点中找出最小的并访问，循环做这个是直到所有点都被访问完！    

这里先贴出例子：

图为算法导论384页图24-6

先大概讲下过程：

图中用铅笔标记了01234五个点

第一步：访问0点，并将0标记为访问，这时候第i个点到0点的距离可以表示为dist[]={0,10,5,∞，∞}

第二步：这个时候，i=0已经访问过了，此时最小的值为5，i=2，即访问点2，这个时候点2可以到达点1，原点到点2的距离dist[2]=5加上从点2直接到点1的距离Cost[2][1]=3等于8<原来的从原点直接到点1的距离dist[1]=10,则将dist[1]更新为8，同理更新其他点，这个时候dist[]={0,8,5,14,7}

第三步：这个时候i=0,2已经被访问过了，dist最小的值为7，访问值为7的点4.。。。。（后面继续，直到所有点被访问完）

实现代码如下：（递归思想）

#include<iostream> 
#include<string>
#include<vector>
#include<deque>
#include <limits.h>
using namespace std;
int MAX=100000;
int Cost[5][5] = { 
	0, 10, 5, MAX, MAX,
	MAX, 0, 2, 1, MAX,
	MAX, 3, 0, 9, 2,
	MAX, MAX, MAX, 0, 4,
	7, MAX, MAX, 6, 0
};
int dist[5] = { 0, MAX, MAX, MAX, MAX };
vector<bool> visited;
void Dijkstra(int number);
int main(void)
{
	ios::sync_with_stdio(false);
	visited.resize(5, false);   //设置初值，都令其为未访问过的。

	Dijkstra(0);

//输出dist[]
	for (int i = 0; i < 5; i++)
	{
		cout << dist[i] << " ";
	}
	return 0;
}
void Dijkstra(int number)
{
	//标记为访问过
	visited[number] = true;
	cout << number << endl;
	//dist[i]数组中保存了从原点到i点的距离，dist[number]则表示从原点到number的距离，如果dist[number]+Cost[number][i]<dist[i],则更新。
	for (int i = 1; i < 5; i++)
	{
		if (dist[number]+Cost[number][i]<dist[i])
		{
			dist[i] = dist[number] + Cost[number][i];
		}
	}
	//接下来时找出为访问过的最小值的点a
	int min=MAX, a=0;
	for (int i = 0; i < 5; i++)
	{
		if (dist[i]<min&&!visited[i])
		{
			min = dist[i];
			a = i;
		}
	}
	
	//如果这一点没有被访问过，则访问之
	if (!visited[a])
	{
		Dijkstra(a);
	}
	
	
}

这是最后输出的结果图，前面输出了访问节点的顺序，后面给出了最终的dist[]。