dijkstra算法

1.dijksta算法是贪婪算法的一个例子，贪婪算法分阶段地求解一个问题，每个阶段把当前的解作为最优解。dijkstra的算法思想与广度优先搜索类似，dijkstra算法可以解决非负权值有向图的单源最短路径问题，算法的结果是得到一颗最短路径树。

2.dijkstra算法的基本思想是：（1）初始时，集合S仅仅包含源点s,d[s]=0,如果其它顶点w和s邻接，d[w]的值为权值，其它顶点若不和s邻接，则距离设置为无穷大（2）从邻接顶点选取与s最近的顶点w，w加入集合S（3）以w为中心，更新源点v到各节点的距离，即如果d[w]+d[w,v]<d[v],则用d[w]+d[w,v]更新s到v的距离。（4）重复（2）（3），直到集合S中包含所有的顶点

3.dijkstra算法复杂度

使用邻接矩阵或者邻接表表示的图，dijkstra算法的复杂度为O(n^2)

4.dijkstra算法的程序为

# include <iostream>
using namespace std;
# include <stdlib.h>
# define NUM 10
# define ARG 10
# define INF 10000
int visited[NUM];
int dist[NUM];
int path[NUM];
struct graph{
	int num;
	int arc;
	int a[NUM][NUM];
	char name[NUM];
};
int main()
{   
	int i;
	void create(graph &g);
	void print(graph &g);
	void dijkstra(graph &g,int i);
	graph g;
	create(g);
	dijkstra(g,0);
	for(i=0;i<g.num;i++)
	{
	cout<<dist[i]<<endl;
	}
	system("pause");
return 0;
}
int locate(graph &g,char a)
{
int i=0;
for(i=0;i<g.num;i++)
	if (g.name[i]==a)
		return i;
return -1;
}

void create(graph &g)    //用邻接矩阵创建图
{
int i,j;
cout<<"input num of nodes and num of edges"<<endl;
cin>>g.num>>g.arc;
for(i=0;i<g.num;i++)
cin>>g.name[i];
for(i=0;i<NUM;i++)
	for(j=0;j<NUM;j++)
		g.a[i][j]=-1;
for(i=0;i<g.arc;i++)
{
	char a,b;
	int i,j,w;
cout<<"input name of nodes"<<endl;
cin>>a>>b>>w;
i=locate(g,a);
j=locate(g,b);
g.a[i][j]=w;
g.a[j][i]=w;
}
}

void dijkstra(graph &g,int i)    //dijkstra算法的程序  
{
int j;
int min;
int t;
for(j=0;j<g.num;j++)   //距离、前驱初始化
{
visited[j]=0;
if(g.a[i][j]>0)
{
dist[j]=g.a[i][j];
path[j]=i;
}
else
{
dist[j]=INF;
path[j]=-1;
}
}
path[i]=i;
dist[i]=i;
for(i=1;i<g.num;i++){   
min=INF;
for(j=0;j<g.num;j++)    //每次选取距离最小的结点
if(!visited[j]&&dist[j]<min)
{
min=dist[j];
t=j;
}

visited[t]=1;           //距离最小的点标记为已访问
for(i=0;i<g.num;i++)
if(!visited[i]&&min+g.a[t][i]<dist[i])
{
dist[i]=min+g.a[t][i];   //更新距离和前驱
path[i]=t;
}
}
}