　http://acm.hdu.edu.cn/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;elsecout << -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;elsecout << -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]);elseprintf("-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;
}

转载于:https://www.cnblogs.com/zhumengdexiaobai/p/8449099.html

12-畅通工程续(多种方法求最短路径)相关推荐

HDOJ1874 ( 畅通工程续 ) 【单源最短路径】
Problem : 1874 ( 畅通工程续 ) Judge Status : Accepted RunId : 5991510 Language : C++ Author : q ...
HDU-1874 畅通工程续（最短路径启蒙题）
hdu 1874比较基础,拿来练各种刚学会的算法比较好,可以避免好多陷阱,典型的最短路模板题畅通工程续 Time Limit: 3000/1000 MS (Java/Others) Memor ...
Hdu1874 最短路径_畅通工程续
Problem Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比另一些方案行 ...
hdu 1874 畅通工程续（求最短距离，dijkstra,floyd）
题目:http://acm.hdu.edu.cn/showproblem.php?pid=1874 /************************************************* ...
HDOJ---1874 畅通工程续[最短路径问题-Dijkstra算法]
转自:http://www.wutianqi.com/?p=1894 畅通工程续 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 327 ...
HDU 1874 畅通工程续 2008浙大研究生复试热身赛（2）
畅通工程续 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submiss ...
HDU-1874畅通工程续（最短路）
畅通工程续 Problem Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比 ...
hdu1874 畅通工程续 floyd入门题学习
畅通工程续 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Subm ...
HDOJ 1874 HDU 1874 畅通工程续 ACM 1874 IN HDU
MiYu原创, 转帖请注明 : 转载自 ______________白白の屋题目地址: http://acm.hdu.edu.cn/showproblem.php?pid=1874 ...
杭电1874畅通工程续
畅通工程续 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Subm ...

12-畅通工程续(多种方法求最短路径)

http://acm.hdu.edu.cn/showproblem.php?pid=1874

畅通工程续

12-畅通工程续(多种方法求最短路径)相关推荐

最新文章

热门文章