最短路径算法

1.算法一：Dijkstra算法

 

         这个算法比较经典，一般的最短路径都可以用这个来解决，耗时也比较少，不过不能处理负权路径按路径长度递增次序产生最短路径算法：
　
         把V分成两组：
　　（1）S：已求出最短路径的顶点的集合
　　（2）V-S=T：尚未确定最短路径的顶点集合
        将T中顶点按最短路径递增的次序加入到S中，
　　保证：
        （1）从源点V0到S中各顶点的最短路径长度都不大于从V0到T中任何顶点的最短路径长度
　　（2）每个顶点对应一个距离值
　　S中顶点：从V0到此顶点的最短路径长度
　　T中顶点：从V0到此顶点的只包括S中顶点作中间顶点的最短路径长度
　　依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的直接路径的权值；或是从V0经S中顶点到Vk的路径权值之和
　　（反证法可证）

 

　　求最短路径步骤
　　算法步骤如下：
　　1. 初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值
　　若存在<V0,Vi>，d(V0,Vi)为<V0,Vi>弧上的权值
　　若不存在<V0,Vi>，d(V0,Vi)为∝
　　2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S
　　3. 对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值比不加W的路径要短，则修改此距离值
　　重复上述步骤2、3，直到S中包含所有顶点，即S=T为止

 

       代码实现如下所示：

 

int edge[201][201];   ///所求网图的邻接矩阵
int used[201];   ///标记是否已生成终点（到源点的最短路径已确定）
int dis[201];   ///存放当前源点v到其他点i的距离
int v;   ///v为源点

void dijkstra()
{
	int i,j,pos,min;
	
	memset(used,0,sizeof(used));
	
	for(i=0;i<n;i++)
		dis[i]=edge[v][i];   ///初始化dis数组
	
	dis[v]=0;
	
	for(i=0;i<n;i++)
	{
		min=1000000;

		for(j=0;j<n;j++)
		{
			if(min>dis[j] && !used[j])   ///在dis中找出最小值
			{
				min=dis[j];
				pos=j;
			}
		}
		
		if(min==1000000)
			break;
		
		used[pos]=1;   ///置顶点v为已生成终点标记
		
		for(j=0;j<n;j++)
		{
			if(dis[j]>dis[pos]+edge[pos][j] && !used[j])   ///修改dis数组
				dis[j]=edge[pos][j]+dis[pos];
		}
	}
	
	if(dis[e]!=1000000) 
		printf("%d\n",dis[e]);
	else 
		printf("-1\n");   ///printf("%d\n",dis[e]!=1000000?dis[e]:-1);  另一种写法
}

 

2.算法二：Floyd算法

 

     算法实现：
           使用一个邻接矩阵存储边权值，两两之间能访问的必为一个有限的数，

    不能访问  则为无穷大（用2^29代替）。 

    注意自身和自身距离为0。
           对于一对顶点 u 和 v，看看是否存在一个断点 w 使得从 u 经过 w 到 v 比

    已知的路径更短（包含原始输入中从 u 直接到 v 的路程）。
           对所有顶点进行如上松弛操作，得到的结果是两点之间的最短路程，

    也可判断两点是否连通。
   
    算法缺点：
           普通的Floyd算法时间复杂度为O(n^3)，对于数据较多的情况容易TLE>

 

   代码实现如下所示：

 

int edge[201][201];   ///所求网图的邻接矩阵

int min(int x,int y)   ///比较函数（求最小值的）
{
	return x>y?y:x;
}

void getedge()   ///初始化
{
	int a,b;
	int i,j,l;   ///循环变量
	
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(i==j)   ///本身与本身的距离为0
				edge[i][j]=0;
			else   ///否则为无穷
				edge[i][j]=1000000;
			//edge[i][j]=(i==j?0:1000000);   这是另一种写法
		}
	}
	
	for(i=0;i<m;i++)
	{
		scanf("%d%d%d",&a,&b,&l);
		
		edge[a][b]=edge[b][a]=min(edge[a][b],l);
	}
	
}

void floyd(int s,int e)
{
	int i,j,k;   ///循环变量
	
	for(k=0;k<n;k++)
	{
		for(i=0;i<n;i++)
		{
			for(j=0;j<n;j++)
			{
				edge[i][j]=min(egde[i][j],edge[i][k]+edge[k][j]);
			}
			
		}
	}

	if(edge[s][e]<1000000)
		printf("%d\n",edge[s][e]);
	else
		printf("-1\n"); 
	///printf("%d\n",edge[s][e]<1000000?edge[s][e]:-1); 另一种写法
}