showproblem.php?pid=1874

　　　　　　　　　　　　　畅通工程续

Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 61833 Accepted Submission(s): 23163

Problem Description

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

Sample Input

3 3 0 1 1 0 2 3 1 2 1 0 2 3 1 0 1 1 1 2

Sample Output

2 -1

Author

linle

Source

2008浙大研究生复试热身赛（2）——全真模拟

Recommend

lcy | We have carefully selected several similar problems for you: 2544 2066 2112 1217 1875

最短路径总结：

1.Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，

在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不存在负权边。

2.Floyd算法的介绍算法的特点：弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。

3.Bell-man:与Dijkstra不同的是，这个算法每次只是从队头拿出结点，修改与之相邻的节点，即进行松弛操作，d[i] <?= d[u]+w[u][i];并不会找d[i]最小的点，它是通过动态的修正、收敛来实现最短路径的。

4.SPFA：适用于权值有负值，且没有负圈的图的单源最短路径，论文中的复杂度O(kE)，k为每个节点进入Queue的次数，且k一般<=2，但此处的复杂度证明是有问题的，其实SPFA的最坏情况应该是O(VE).

方法一：Dijkstra算法

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
int dist[2000];
int mp[2000][2000];
int visit[2000];
const int INF = 0x3f3f3f3f;
int n;

void djstl(int s){
	memset(visit, 0, sizeof(visit));
	visit[s] = 1;
	for(int i = 0; i < n; i++){
		dist[i] = mp[s][i];
	}
	dist[s] = 0;  //这个必须单独赋值，到自己的距离为零 
	for(int i = 0; i < n; i++){
		int minc = INF, p;
		for(int j = 0; j < n; j++){
			if(visit[j] == 0 && dist[j] < minc){
				minc = dist[j];
				p = j;
			}
		}
		if(minc == INF)
			return ;  
		visit[p] = 1;
		for(int i = 0; i < n; i++){
			if(visit[i] == 0 && dist[i] > dist[p] + mp[p][i])
				dist[i] = dist[p] + mp[p][i];
		}
	}
}

int main(){
	int m;
	while(cin >> n >> m){
		memset(mp, INF, sizeof(mp));
		for(int i = 0; i < m; i++){
			int x, y, w;
			cin >> x >> y >> w;
			if(mp[x][y] > w){
				mp[x][y] = mp[y][x] = w;
			}
		}
		int s, e;
		cin >> s >>e;
		djstl(s);
		if(dist[e] < INF)  // 与所求点是否连通不能根据它的返回值判断 
			cout << dist[e] << endl;
		else
			cout << -1 << endl;
	}	
	return 0;
}

　　地杰斯特拉的邻接表：（尚有问题）

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
int dist[2000];
//int mp[2000][2000];
vector <int> mp[2002];
vector <int> w[2002];
int visit[2000];
const int INF = 0x3f3f3f3f;
int n;

void djstl(int s){
	memset(visit, 0, sizeof(visit));
	visit[s] = 1;
//	for(int i = 0; i < n; i++){
//		dist[i] = mp[s][i];
//	}
	memset(dist, INF, sizeof(dist));
	for(int i = 0; i < mp[s].size(); i++){
		if(dist[mp[s][i]] > w[s][i]) //要注意到同一条边以不同权值进行存储的情况
			dist[mp[s][i]] = w[s][i];
	}

	dist[s] = 0;  //这个必须单独赋值，到自己的距离为零 
	for(int i = 0; i < n; i++){
		int minc = INF, p;
		for(int j = 0; j < n; j++){   //遍历每个点 
			if(visit[j] == 0 && dist[j] < minc){
				minc = dist[j];
				p = j;
			}
		}
		if(minc == INF)
			return ;  
		visit[p] = 1;
//		for(int i = 0; i < n; i++){  //更新p点周边点到s的距离 
//			if(visit[i] == 0 && dist[i] > dist[p] + mp[p][i])
//				dist[i] = dist[p] + mp[p][i];
//		}
		for(int i = 0; i < mp[p].size(); i++){
			if(visit[mp[p][i]] == 0 && dist[mp[p][i]] > dist[p] + w[p][i])
				dist[mp[p][i]] = dist[p] + w[p][i];
		} 
	}
}

int main(){
	int m;
	while(cin >> n >> m){
		memset(mp, INF, sizeof(mp));
		for(int i = 0; i < m; i++){
			int x, y, v;
			cin >> x >> y >> v;
//			if(mp[x][y] > v){
//				mp[x][y] = mp[y][x] = v;
//			}
			mp[x].push_back(y);  //要注意到同一条边以不同权值进行存储的情况 
			w[x].push_back(v);
			mp[y].push_back(x);  //无向图 
			w[y].push_back(v);
		}
		int s, e;
		cin >> s >>e;
		djstl(s);
		if(dist[e] < INF)  // 与所求点是否连通不能根据它的返回值判断 
			cout << dist[e] << endl;
		else
			cout << -1 << endl;
	}	
	return 0;
}

　　方法二：Flord算法

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int INF = 0x3f3f3f3f;
int map[2005][2005];
int v, e;

void floyd(){
	for(int k = 0; k < v; k++){  //尝试每一个中转站 
		for(int i = 0; i < v; i++){
			for(int j = 0; j < v; j++){
				if(map[i][j] > map[i][k] + map[k][j])
					map[i][j] = map[i][k] + map[k][j];
			}
		}
	}
}

int main(){
	while(scanf("%d%d", &v, &e) == 2){
		for(int i = 0; i <= v; i++){
			for(int j = i + 1; j <= v; j++)
				map[i][j] = map[j][i] = INF;
			map[i][i] = 0; 
		}
		int x, y, z;
		for(int i = 1; i <= e; i++){
			scanf("%d%d%d", &x, &y, &z);
			if(map[x][y] > z){              //坑逼，可能两点之间有多条直接相通的路,只记录最短的那条 
            	map[y][x] = map[x][y] = z;  //无向图 
			} 
		}
		int s, e;
		scanf("%d%d", &s, &e);
		floyd();
//		for(int i = 0; i <= v; i++){
//			printf("%d\n", map[1][i]);
//		}
		if(map[s][e] < INF)
			printf("%d\n", map[s][e]);
		else
			printf("-1\n");
	}
		
	return 0;
}

　　方法三：Bellman—ford算法

//二维邻接矩阵
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int MAX = 0x3f3f3f3f;
int map[2005][2005];
int d[2005];
int v, e;

void bellman(int sta){
	for(int i = 0; i < v; i++){
		d[i] = map[sta][i];
	}
	d[sta] = 0;
	int flag = 1; 
	for(int i = 0; i < v - 1; i++){ 	//最多查找v-1次 
		flag = 1; 
		for(int j = 0; j < v; j++){		//尝试更换当前位置的字 
			for(int k = 0; k < v; k++){ //看是是否有连通的更短中转站 
				if(d[j] > d[k] + map[k][j]){
					d[j] = d[k] + map[k][j];
					flag = 0;
				}
			}
		}
		if(flag)
			break;
	}
}

int main(){
	while(scanf("%d%d", &v, &e) == 2){
		memset(map, MAX, sizeof(map));
		int x, y, z;
		for(int i = 0; i < e; i++){
			scanf("%d%d%d", &x, &y, &z);
			if(map[x][y] > z){
				map[x][y] = map[y][x] = z;
			}
		}
		int sta, end; 
		scanf("%d%d", &sta, &end);
		bellman(sta);
		if(d[end] < MAX){
			printf("%d\n", d[end]);
		}
		else{
			printf("-1\n");
		}
	}
	return 0;
} 
//一维数组
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAX = 0x3f3f3f3f;
int v[1005], u[1005]; //起点，终点 
int w[1005];		  //权值	
int n, m;     //顶点数，边数
int d[205];  //路径数组 

void bellman(int s){
	memset(d, MAX, sizeof(d));
	d[s] = 0; //必须初始化这个 
	int flag = 1;
	for(int k = 0; k < n - 1; k++){
		flag = 1;
		for(int i = 0; i < m; i++){      //遍历每一条边 
			if(d[u[i]] > d[v[i]] + w[i]){//如果这条边的终点的d[]值小于起始点的d[]值加上这条边的权值，则更新d 
				d[u[i]] = d[v[i]] + w[i];
				flag = 0; 
			}  
		}
		if(flag){
			break;
		}
	}
}

int main(){
	int ss;
	while(scanf("%d%d", &n, &m) == 2){
		for(int i = 0; i < m; i++){
			scanf("%d%d%d", &v[i], &u[i], &w[i]);
			v[i+1] = u[i];  //是无向的需要存双边 
			u[i+1] = v[i];
			w[i+1] = w[i];
			i++; m++;       //则边的总数要更新一下 
		}
		int s, e;
		scanf("%d%d", &s, &e);
		bellman(s);
		if(d[e] < MAX){
			printf("%d\n", d[e]);
		}
		else{
			printf("-1\n");
		}
	}
	return 0;
}

　　方法四：Spfa算法（Shortest Path Faster Algorithm）

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int MAX = 0x3f3f3f3f;
vector <int>v1[205]; //v1[i]表示i到的终点 
vector <int>v2[205]; //v2[i]表示i和v1[i]的边的权值 
int visit[205];      //表示是否已经在队列里面 
int d[205];
int n, m, ss;

void spfa(int ss){
	memset(d, 0x3f, sizeof(d));
	d[ss] = 0;
	queue <int>mq;
	mq.push(ss);
	visit[ss] = 1;
	while(!mq.empty()){
		int x = mq.front();
		mq.pop();
		visit[x] = 0;
		for(int i = 0; i < v1[x].size(); i++){ //只遍历x的邻点,对bellman-ford的优化 
			int v = v1[x][i];
			int len = v2[x][i];
			if(d[v] > d[x] + len){
				d[v] = d[x] + len;
				if(visit[v] == 0){ //这个在上一个if里面，只有别更新了，才有可能影响其他点，才放入队列 
					mq.push(v);
					visit[v] = 1;
				}
			} 
		}
	}
}

int main(){
	while(scanf("%d%d", &n, &m) == 2){
		memset(visit, 0, sizeof(visit));
		memset(v1, 0, sizeof(v1));
		memset(v2, 0, sizeof(v2));
		int x, y, z;
		for(int i = 0; i < m; i++){
			cin >> x >> y >> z;
//			if(z < v2[x][y]){ //两个点多条路，去最短的 
				v2[x].push_back(z);  //压入权值 
				v1[x].push_back(y);  //压入x的另一个顶点 
				v1[y].push_back(x);	 //无向的话，要反向压一遍 
				v2[y].push_back(z);
//			}
		}
		int end; 
		scanf("%d%d", &ss, &end);
		spfa(ss);
		if(d[end] < MAX){
			printf("%d\n", d[end]);
		}
		else{
			printf("-1\n");
		}
	
	}
	return 0;
}

posted on 2018-02-14 23:33 ystraw 阅读(164) 评论(0) 收藏举报