最短路径问题

单源最短路问题有权图(Dijkstra算法)

Description

给一个n(1 ≤ n ≤ 2500) 个点 m(1 ≤ m ≤ 6200) 条边的无向图，求 s 到 t 的最短路。

Input

第一行四个由空格隔开的整数 n、m、s、t。

之后的 m 行，每行三个正整数 s​i​​、t​i​​、w​i​​(1≤w​i​​≤10​9​​)，表示一条从s​i​​ 到 t​i​​ 长度为 w​i​​ 的边。

Output

一个整数，表示从s 到t 的最短路径长度。数据保证至少存在一条道路。

Sample Input

7 11 5 4
2 4 2
1 4 3
7 2 2
3 4 3
5 7 5
7 3 3
6 1 1
6 3 4
2 4 3
5 6 3
7 2 1

Sample Output

7

---

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;


public class Main {
	static final int N = 2501;
	static final int M = 6501;
	static final int INF = 0x3f3f3f3f;
	static int G[][] = new int[N][N];  //建立图
	static int dist[] = new int[N];   //起始点到每个结点的距离
	static int vis[] = new int[N];   //标记结点是否被遍历过
	static int path[] = new int[N];  //标记路径
	static int n,m;  //顶点数 边数
	static int s, t;  //起点终点
	
	static void Init()  //初始化邻接矩阵
	{
		for(int i = 1; i <= n; i++) { 
			for(int j = 1; j <= n; j++) {
				if(i == j) G[i][j] = 0;   //从当前点到当前点的距离为0  矩阵对角线
				else G[i][j] = INF;        //其他区域初始化为无穷大
			}
		}
	}
	
	static void Dijkstra() 
	{
		for(int i = 1; i <= n; i++) {
			dist[i] = G[s][i];   //对起始点到i的距离的初始化
			path[i] = -1;		//路径全都初始化为-1
		}
		vis[s] = 1;  //起始点标记为1
		for(int i = 1; i <= n; i++) {    //每次找距离起点距离最小的值 v，对周围的结点距离起点的距离进行更新  遍历n次
			int min = INF,v = 0;		//取最小值
			//遍历所有的点  找到距离起点最小的点
			for(int j = 1; j <= n; j++) {   
				if(vis[j] == 0 && dist[j] < min) {
					min = dist[j];
					v = j;  //每次找到距离起点最近的点
				}
			}
			vis[v] = 1;
			//松弛操作
			for(int k = 1; k <= n; k++) {  //遍历v的邻接点, 更新邻接点k的距离dist[k]
				if(vis[k] == 0 && dist[v] + G[v][k] < dist[k]) {
					dist[k] = dist[v] + G[v][k];
					path[k] = v;
				}
			}
		}
		System.out.println(dist[t]);
	}
	
	//递归输出最短路径
	static void search(int x) {
		if(x == -1) {
			System.out.print(x);
			return;
		}
		search(path[x]);
		System.out.print("-->" + x);
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		s = sc.nextInt();
		t = sc.nextInt();
		Init();
		int c1,c2,w;
		for(int i = 0; i < m;i++) {
			c1 = sc.nextInt();
			c2 = sc.nextInt();
			w = sc.nextInt();
			if(w < G[c1][c2]) {
				G[c1][c2] = G[c2][c1] = w;
			}
		}
		Dijkstra();
		search(t);
	}
	
}

Description

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运
回到赛场的时候，却是非常累的！
所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，
标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，
每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间
走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input

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

Sample Output

3
2

---

#include<iostream>
#include<string.h>
using namespace std;
#define N 101
#define INF 0x3f3f3f3f
int G[N][N];
int dist[N]; //起始点到每个i的距离 
int vis[N];	//标记是否遍历过 
int path[N]; //路径 
int n,m;   //顶点数，边数
void Init()
{
	memset(vis,0,sizeof(vis)); //初始化为0 
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			if(i == j) G[i][j] = 0;
			else G[i][j] = INF;
		}
	}
}
//1 商店所在地  n  赛场所在地 
void Dijkstra()  //最短路算法 
{
	for(int i = 1; i <= n; i++){
		dist[i] = G[1][i];
		path[i] = 1;
	}
	vis[1] = 1;
	for(int i = 1; i <= n; i++){
		int min = INF,v;
		for(int j = 1; j <= n; j++){
			if(!vis[j] && dist[j] < min){
				min = dist[j];
				v = j;       //每次找到距离起始点最近的点  
			}
		}
		vis[v] = 1;
		for(int k = 1; k <= n; k++){
			if(!vis[k] && dist[v] + G[v][k] < dist[k]){
				dist[k] = dist[v] + G[v][k];
				path[k] = v;
			}
		} 
	}
	cout<<dist[n]<<endl;
}

int main()
{
	while(true){
		cin>>n>>m;
		if(n == 0 && m == 0) break;
		int x,y,w;
		Init();
		for(int i = 0; i < m; i++){
			cin>>x>>y>>w;
			G[x][y] = G[y][x] = w;
		}
		Dijkstra();
	}	
} 

多源最短路问题(Floyd算法)

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

---

#include<iostream>
using namespace std;
#define N 201
#define INF 0x3f3f3f3f
int G[N][N]; 
int D[N][N];//D[i][j] = w  表示i到j的距离为w 
int path[N][N];
int n,m; //城镇数目，已修建的道路
int s,t; //起点，终点 
void Init()
{
	//初始化 距离为-1
	//初始化图对角线为0，其余区域为无穷大 
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			if(i == j) G[i][j] = 0;
			else G[i][j] = INF;
		}
	}
	
}

void Floyd()
{	
	int i,j,k;
	//初始化 
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			D[i][j] = G[i][j];
			path[i][j] = -1;
		}
	}
	for(k = 0; k < n; k++ ){  //表示遍历每一个结点
	//判断以k为中间路的路径是否能让i到j的距离更小
		for(i = 0; i < n; i++){
			for(j = 0; j < n; j++){
				if(D[i][k] + D[k][j] < D[i][j]){
					D[i][j] = D[i][k] + D[k][j];
					path[i][j] = k;
				}
			}
		}
	}
	if(D[s][t] != INF)
		cout<<D[s][t]<<endl;
	else
		cout<<"-1"<<endl; 
}

void search(int x,int y)  //x起点，y终点 
{
	int k = path[x][y];
	if(k == -1){
		cout<<x;
		return ;
	}
	search(x,k);
	cout<<" "<<k<<endl;
}

int main()
{
	while(cin>>n>>m){
		Init();
		int x,y,w;
		for(int i = 0; i < m; i++){
			cin>>x>>y>>w;
			if(G[x][y] > w){
				G[x][y] = G[y][x] = w;
			}
		}
		cin>>s>>t;  //起点和终点
		Floyd(); 
		search(s,t);
	}
}