【8】最小生成树、最短路、关键路径

1. 最小生成树
   (1) Prim
   (2) Kruskal
2. 最短路
   (1) 单源最短路 Dijkstra
   (2) 多源汇最短路 Floyd
3. 关键路径

最小生成树（MST）是指在无向图中，不一定唯一
求总边权和最小和最大边权最小本质上相同

Prim算法求最小生成树

题目描述

给定一个 $n$ 个点 $m$ 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

给定一张边带权的无向图 $G=(V,E)$，其中 $V$ 表示图中点的集合，$E$ 表示图中边的集合，$n=|V|$，$m=|E|$。

由 $V$ 中的全部 $n$ 个顶点和 $E$ 中 $n-1$ 条边构成的无向连通子图被称为 $G$ 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 $G$ 的最小生成树。

输入格式

第一行包含两个整数 $n$ 和 $m$。

接下来 $m$ 行，每行包含三个整数 $u,v,w$，表示点 $u$ 和点 $v$ 之间存在一条权值为 $w$ 的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

数据范围

$1>=n>=500$,
$1>=m>=10^5$,
图中涉及边的边权的绝对值均不超过 $10000$。

输入样例：

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4

输出样例：

6

---

prim C++ 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 510, M = 1e5 + 10, INF = 0x3f3f3f3f;
int g[N][N], dist[N];
int n, m;
bool st[N];

int prim(){
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	int res = 0;
	for(int i = 0; i < n; i++){
		int t = -1;
		for(int j = 1; j <= n; j++)
			if(!st[j] && (t == - 1 || dist[t] > dist[j]))
				t = j;
		if(dist[t] == INF) return INF;
		st[t] = true;
		res += dist[t];
		for(int j = 1; j <= n; j++)
			dist[j] = min(dist[j], g[t][j]);
	}
	return res;
}
int main(){
	scanf("%d%d", &n, &m);
	memset(g, 0x3f, sizeof g);
	while(m--){
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		g[a][b] = g[b][a] = min(g[a][b], c);
	}
	int res = prim();
	if(res == INF) puts("impossible");
	else printf("%d\n", res);
	return 0;
}

kruskal C++ 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 510, M = 1e5 + 10;
int n, m;
int p[N];
struct Edge{
	int a, b, c;
	bool operator< (const Edge& t) const{
		return c < t.c;
	}
}e[M];

int find(int x){
	if(p[x] != x) p[x] = find(p[x]);
	return p[x];
}
int main(){
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; i++)
		scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].c);
	sort(e, e + m);
	for(int i = 1; i <= n; i++) p[i] = i;
	
	int res = 0, cnt = n;
	for(int i = 0; i < m; i++){
		int a = e[i].a, b = e[i].b, c = e[i].c;
		if(find(a) != find(b)){
			res += c;
			cnt --;
			p[find(a)] = find(b);
		}
	}
	if(cnt > 1) puts("impossible");
	else printf("%d\n", res);
	return 0;
}

dijkstra一定是按照每个点到源点的最短路径排序求出来的
Dijkstra求最短路 I

题目描述

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $-1$。

输入格式

第一行包含整数 $n$ 和 $m$。

接下来 $m$ 行每行包含三个整数 $x,y,z$，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$。

输出格式

输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。

如果路径不存在，则输出 $-1$。

数据范围

$1<=n<=500$,
$1<=m<=10^5$,
图中涉及边长均不超过10000。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

---

C++ 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 510, M = 1e5 + 10, INF = 0x3f3f3f3f;
int n, m;
int g[N][N], dist[N];
bool st[N];
int dijkstra(){
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for(int i = 0; i < n; i++){
		int t = -1;
		for(int j = 1; j <= n; j++)
			if(!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		st[t] = true;
		for(int j = 1; j <= n; j++)
			dist[j] = min(dist[j], dist[t] + g[t][j]);
	} 
	return dist[n];
}
int main(){
	scanf("%d%d", &n, &m);
	memset(g, 0x3f, sizeof g);
	while(m --){
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		g[a][b] = min(g[a][b], c);
	}
	int res = dijkstra();
	if(res == INF) puts("-1");
	else printf("%d\n", res);
	return 0;
}

Floyd求最短路

题目描述

给定一个 $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

---

C++ 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 210, INF = 0x3f3f3f3f;
int n, m, Q;
int d[N][N];
int main(){
	scanf("%d%d%d", &n, &m, &Q);
	memset(d, 0x3f, sizeof d);
	for(int i = 1; i <= n; i++) d[i][i] = 0;
	
	while(m --){
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		d[a][b] = min(d[a][b], c);
	}
	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]);
				
	while(Q --){
		int a, b;
		scanf("%d%d", &a, &b);
		int c = d[a][b];
		if(c > INF / 2) puts("impossible");
		else printf("%d\n",c);
	}
	return 0;
}