多源汇最短路问题-具有多个源点
Floyd算法 O(n^3)-动态规划
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数n，m，k
接下来m行，每行包含三个整数x，y，z，表示点x和点y之间存在一条有向边，边长为z。
接下来k行，每行包含两个整数x，y，表示询问点x到点y的最短距离。
输出格式
共k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出“impossible”。
数据范围
1≤n≤2001≤n≤200
1≤k≤n21≤k≤n2
1≤m≤200001≤m≤20000
图中涉及边长绝对值均不超过10000。
输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1
代码：
#include using namespace std; const int N = 210, M = 2e+10, INF = 1e9; int n, m, k, x, y, z; int d[N][N]; void floyd() { for(int k = 1; k <= n; k++) for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]); } int main() { cin >> n >> m >> k; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) if(i == j) d[i][j] = 0; else d[i][j] = INF; while(m–) { cin >> x >> y >> z; d[x][y] = min(d[x][y], z); //注意保存最小的边 } floyd(); while(k–) { cin >> x >> y; if(d[x][y] > INF/2) puts(“impossible”); //由于有负权边存在所以约大过INF/2也很合理 else cout << d[x][y] << endl; } return 0; }
文字性复习
Dijkstra-朴素O(n^2)
初始化距离数组, dist[1] = 0, dist[i] = inf;
for n次循环 每次循环确定一个min加入S集合中，n次之后就得出所有的最短距离
将不在S中dist_min的点->t
t->S加入最短路集合
用t更新到其他点的距离
Dijkstra-堆优化O(mlogm)
利用邻接表，优先队列
在priority_queue[HTML_REMOVED], greater[HTML_REMOVED] > heap;中将返回堆顶
利用堆顶来更新其他点，并加入堆中类似宽搜
Bellman_fordO(nm)
注意连锁想象需要备份, struct Edge{inta,b,c} Edge[M];
初始化dist, 松弛dist[x.b] = min(dist[x.b], backup[x.a]+x.w);
松弛k次，每次访问m条边
Spfa O(n)~O(nm)
利用队列优化仅加入修改过的地方
for k次
for 所有边利用宽搜模型去优化bellman_ford算法
更新队列中当前点的所有出边
Floyd O(n^3)
初始化d
k, i, j 去更新d
import java.util.Scanner;
/*
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。
数据保证图中不存在负权回路。
输入格式 第一行包含三个整数n，m，k 接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。 接下来k行，每行包含两个整数x，y，表示询问点x到点y的最短距离。 输出格式 共k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出“impossible”。 数据范围 1≤n≤200, 1≤k≤n^2 1≤m≤20000, 图中涉及边长绝对值均不超过10000。 输入样例： 3 3 2 1 2 1 2 3 2 1 3 1 2 1 1 3 输出样例： impossible 1
*/
public class Main {
/解题思路，动态规划的思想
假设节点序号是从1到n。
假设f[0][i][j]是一个nn的矩阵，第i行第j列代表从i到j的权值，如果i到j有边，那么其值就为ci,j（边ij的权值）。
如果没有边，那么其值就为无穷大。
f[k][i][j]代表（k的取值范围是从1到n），在考虑了从1到k的节点作为中间经过的节点时，从i到j的最短路径的长度。 比如，f[1][i][j]就代表了，在考虑了1节点作为中间经过的节点时，从i到j的最短路径的长度。 分析可知，f[1][i][j]的值无非就是两种情况，而现在需要分析的路径也无非两种情况，i=>j，i=>1=>j： 【1】f[0][i][j]：i=>j这种路径的长度，小于，i=>1=>j这种路径的长度 【2】f[0][i][1]+f[0][1][j]：i=>1=>j这种路径的长度，小于，i=>j这种路径的长度 形式化说明如下： f[k][i][j]可以从两种情况转移而来： 【1】从f[k−1][i][j]转移而来，表示i到j的最短路径不经过k这个节点 【2】从f[k−1][i][k]+f[k−1][k][j]转移而来，表示i到j的最短路径经过k这个节点 总结就是：f[k][i][j]=min(f[k−1][i][j],f[k−1][i][k]+f[k−1][k][j]) 从总结上来看，发现f[k]只可能与f[k−1]有关。 */ static int N = 210; static int n, m, q; static int[][] d = new int[N][N]; static int INF = (int)1e9; public static void main(String[] args) { Scanner sc = new Scanner(System.in); n = sc.nextInt(); m = sc.nextInt(); q = sc.nextInt(); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i == j) d[i][j] = 0; else d[i][j] = INF; } } for(int i = 0; i < m; i++) { int a = sc.nextInt(), b = sc.nextInt(), w = sc.nextInt(); d[a][b] = Math.min(d[a][b], w); } Floyd(); while (q-- > 0) { int a = sc.nextInt(), b = sc.nextInt(); if (d[a][b] > INF / 2) System.out.println("impossible"); else System.out.println(d[a][b]); } } private static void Floyd() { for (int k = 1; k <= n; k++) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]); } } } }
}
