博客

一种多源最短路径算法。

时间复杂度

DP转移方程

参考链接

#include<iostream>
#include<cstring>
#define MAX 0x3f3f3f3f
using namespace std; 
int d[101][101];
int main(void)
{
	int n,m;//节点数，边数
	while(cin>>n>>m){
		if(n==0&m==0) break;
		memset(d,0,sizeof(d)); 
		int a,b,c;
		for(int i=1;i<=n;i++){//初始化 
			for(int j=1;j<=n;j++){
				if(i!=j) d[i][j]=MAX; 
				else d[i][j]=0;
			}
		}
		for(int i=0;i<m;i++){
			cin>>a>>b>>c;
			d[a][b]=d[b][a]=c;
		}
		for(int k=1;k<=n;k++){
			for(int i=1;i<=n;i++){
				for(int j=1;j<=n;j++){
					if(d[i][k]+d[k][j]<d[i][j]) 
						d[i][j]=d[i][k]+d[k][j];
					//如果经过K结点有更短的路径 
				}
			}
		}
		cout<<d[1][n]<<endl;
	} 
	return 0;
 } 

最短路径问题

题目描述

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

输入描述:

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点t。n和m为0时输入结束。 (1<n<=1000, 0<m<100000, s != t)

输出描述:

输出一行有两个数， 最短距离及其花费。

输入

3 2
1 2 5 6
2 3 4 5
1 3
0 0

输出

9 11

//Floyd
//仅练习,实际会超时 
#include<iostream>
#include<cstring>
#define MAX 0x3f3f3f3f 
const int N = 1000+10;
using namespace std;
int dist[N][N];
int cost[N][N];
int Add(int x,int y){
	return (x==MAX||y==MAX)?MAX:x+y;
}
void init(){
	for(int i=0;i<N;i++){
		for(int j=0;j<N;j++){
			if(i==j) dist[i][j]=cost[i][j]=0;
			else dist[i][j]=cost[i][j]=MAX;
		}
	}
} 
void floyd(int n){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(Add(dist[i][k],dist[k][j])<dist[i][j]){
					dist[i][j]=dist[j][i]=Add(dist[i][k],dist[k][j]);
					cost[i][j]=cost[j][i]=Add(cost[i][k],cost[k][j]);
				}
				if(Add(dist[i][k],dist[k][j])==dist[i][j]&&Add(cost[i][k],cost[k][j])<cost[i][j]){
					cost[i][j]=cost[j][i]=Add(cost[i][k],cost[k][j]);
				}
			}
		}
	}
}
int main(void)
{
	int n,m;
	while(cin>>n>>m){
		if(n==0&&m==0) break;
		init();
		int a,b,d,p,s,t;
		while(m--){
			cin>>a>>b>>d>>p;
			if(d<dist[a][b]){
				dist[a][b]=dist[b][a]=d;
				cost[a][b]=cost[b][a]=p;
			}
			if(d==dist[a][b]&&p<cost[a][b]){
				cost[a][b]=cost[b][a]=p;
			}
		}
		floyd(n);
		cin>>s>>t;
		cout<<dist[s][t]<<" "<<cost[s][t]<<endl;
	}
 } 

这道题使用Floyd可能超时，应使用Dijsktra算法。

//Dijkstra
#include<iostream>
#include<vector>
#define MAX 0x3f3f3f3f
const int N = 1000+10;
using namespace std;
struct edge{
	int next,dist,cost;
};
int dist[N];
int cost[N];
bool mark[N];
vector<edge> E[N]; 
void init(){
	for(int i=0;i<N;i++){
		dist[i]=-1;
		cost[i]=MAX;//?
		mark[i]=false;
		E[i].clear();	//clear()方法直接清空 
	}
}
int main(void){
	int n,m,s,t;
	while(cin>>n>>m){
		if(n==0&&m==0) break; 
		init();
		int a,b,d,p;
		while(m--){
			cin>>a>>b>>d>>p;
			edge temp;
			temp.dist=d;
			temp.cost=p;
			temp.next=b;
			E[a].push_back(temp);
			temp.next=a;
			E[b].push_back(temp);
		}
		cin>>s>>t;
		int newP = s;
		dist[s]=0;cost[s]=0;
		mark[s]=true;
		for(int k=0;k<n-1;++k){
			for(int i=0;i<E[newP].size();i++){
				int n = E[newP][i].next;
				int d = E[newP][i].dist;
				int c = E[newP][i].cost;
				if(mark[n]==true) continue;
				if(dist[n]==-1||dist[newP]+d<dist[n]||(dist[newP]+d==dist[n]&&cost[newP]+c<cost[n])){
					dist[n] = dist[newP]+d;
					cost[n] = cost[newP]+c; 
				}
			}
			int min = MAX;
			for(int i=1;i<=n;i++){
				if(mark[i]==true) continue;
				if(dist[i]==-1) continue;
				if(dist[i]<min){
					min = dist[i];
					newP = i;
				}
			} 
			mark[newP]=true;
		}
		cout<<dist[t]<<" "<<cost[t]<<endl;
	}
	return 0;
}