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)，分别代表起点和终点。
每组数据第一行包含两个正整数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
Recommend
最短路径总结：
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
", map[1][i]);
// }
if(map[s][e] < INF)
printf("%d
", map[s][e]);
else
printf("-1
");
}
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
", d[end]);
}
else{
printf("-1
");
}
}
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
", d[e]);
}
else{
printf("-1
");
}
}
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
", d[end]);
}
else{
printf("-1
");
}
}
return 0;
}