迪杰斯特拉算法求最短路径 C++代码实现

http://blog.csdn.net/hackerain/article/details/6055925

#define MAX 1000000
#define MAX_VERTEX_NUM 20
typedef struct
{
	std::string vexs[MAX_VERTEX_NUM];//顶点名字
	int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//邻接矩阵
	int vertexnum,edgenum;//顶点和边数目
}MGraph;
void CreateDN_AM(MGraph &G,int n,int e)
{
	G.vertexnum=n;
	G.edgenum=e;
	int i,j,k;
	int weight;
	for(i=0;i<n;i++)
		cin>>G.vexs[i];//输入顶点信息
	for(i=0;i<n;i++)
		for(j=0;j<n;j++)
			G.edges[i][j]=MAX;
	for(k=0;k<e;k++)
	{
		cin>>i>>j>>weight;
		G.edges[i][j]=weight;
	}
}
//v到其余各个顶点的路径
void ShortestPath_DJ(MGraph &G,int v)
{
	int i,j,k,min;
	int final[MAX_VERTEX_NUM];//该数组用来标识顶点是否已经确定了最短路径
	int dist[MAX_VERTEX_NUM];
	std::string path[2*MAX_VERTEX_NUM];
	for(i=0;i<G.vertexnum;i++)
	{//初始化工作
		dist[i]=G.edges[v][i];
		if(dist[i]<MAX)
			path[i]=G.vexs[v]+G.vexs[i];
		else
			path[i]="";
		final[i]=0;
	}
	dist[v]=0;
	final[v]=1;
	for(j=1;j<G.vertexnum;j++)
	{
		min=MAX;
		for(i=0;i<G.vertexnum;i++)
		{
			if(dist[i]<min&&final[i]==0)
			{
				min=dist[i];
				k=i;
			}
		}//找到dist数组中最小值的位置k
		cout<<path[k]<<" "<<dist[k]<<endl;
		final[k]=1;
		for(i=0;i<G.vertexnum;i++)
		{
			if(dist[i]>dist[k]+G.edges[k][i]&&final[i]==0)
			{
				dist[i]=dist[k]+G.edges[k][j];
				path[i]=path[k]+G.vexs[i];
			}
		}
	}
}

int main()
{
	MGraph G;
	CreateDN_AM(G,7,8);
	ShortestPath_DJ(G,0);
	return 0;
}

 

迪杰斯特拉算法主要是采用了一个dist一维数组，来存储源点到其它顶点的最短路径，然后不断更新。

 

#define N 6
#define MAX 100
std::string vexs[N];
int edge[N][N];//边表
int edgenum;
void dijstra(int v)
{
	int flag[N];//标志数组
	memset(flag,0,N);
	int dist[N];//最短路径的值
	for(int temp=0;temp<N;temp++)
		dist[temp]=MAX;
	std::string path[2*N];//路径
	for(int i=0;i<N;i++)
	{
		if(edge[i][v]<MAX)
		{
			dist[i]=edge[i][v];
			std::string temp=" ";
			path[i]=vexs[i]+temp+vexs[v];
		}
		flag[i]=0;
	}
	flag[v]=1;
	dist[v]=0;
	for(int j=1;j<N;j++)
	{
		int min=MAX;
		int k=0;
		for(int i=0;i<N;i++)
		{
			//找到最小的值
			if(flag[i]==0&&dist[i]<min)
			{
				min=dist[i];
				k=i;
			}
		}
		flag[k]=1;
		//输出
		cout<<dist[k]<<" "<<path[k].c_str()<<" "<<endl;
		for(int i=0;i<N;i++)
		{
			if(0==flag[i]&&edge[k][i]+dist[k]<dist[i])
			{
				dist[i]=edge[k][i]+dist[k];
				std::string temp=" ";
				path[i]=vexs[i]+temp+path[k];
			}
		}
	}
}

int main()
{
	for(int i=0;i<N;i++)
	{	
		cin>>vexs[i];
	}
	cin>>edgenum;
	for(int i=0;i<N;i++)
	{
		for(int j=0;j<N;j++)
		{
			edge[i][j]=MAX;
		}
	}
	int weight;int j;int k;
	for(int i=0;i<edgenum;i++)
	{
		cin>>j>>k>>weight;
		edge[j][k]=weight;
		edge[k][j]=weight;
	}
	dijstra(0);
	return 0;
}

 

 

 

 

 Prim算法：

#define N 6
#define NUM 6
#define MAX 100
std::string vexs[N];
int edge[N][N];//边表
int edgenum;

int prim(int v)
{
 int visited[N];
 int dist[N];
 for(int i=0;i<N;i++)
  dist[i]=MAX;
 for(int i=0;i<N;i++)
 {
  if(edge[v][i]<MAX)
  {
   dist[i]=edge[v][i];
  }
  visited[i]=0;
 }
 visited[v]=1;
 dist[v]=0;
 int min;int pos;
 for(int j=1;j<N;j++)
 {
  min=MAX;
  pos=0;
  for(int i=0;i<N;i++)
  {
   if(visited[i]==0&&dist[i]<min)
   {
    min=dist[i];
    pos=i;
   }
  }
  visited[pos]=1;
  //松弛
  for(int i=0;i<N;i++)
  {
   if(!visited[i]&&edge[pos][i]<dist[i])
   {
    dist[i]=edge[pos][i];
   }
  }
 }
 int sum=0;
 for(int i=0;i<N;i++)
  sum+=dist[i];
 return sum;
}