最小生成树
Floyd算法O(n^3)- 动态规划
思路
f[i, j, k]
表示从i
走到j
的路径上除i
和j
点外只经过1
到k
的点的所有路径的最短距离。那么f[i, j, k] = min(f[i, j, k - 1], f[i, k, k - 1] + f[k, j, k - 1])
- 读入邻接矩阵,每次通过动态规划转换成从i到j的最短距离矩阵
- 在下面代码中,判断从a到b是否是无穷大距离时,需要进行
if(t > INF/2)
判断,而非是if(t == INF)
判断,原因是INF是一个确定的值,并非真正的无穷大,会随着其他数值而受到影响,t大于某个与INF
相同数量级的数即可。 - 注意邻接矩阵的初始化。
题目描述
给定一个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≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过10000。
输入样例:
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例:
impossible
1
代码
#include <iostream>
#include <cstring>
using namespace std;
const int N = 210, INF = 1e9;
int d[N][N];
int main()
{
int n, m, q;
cin >> n >> m >> q;
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 --)
{
int x, y, k;
cin >> x >> y >> k;
d[x][y] = min(d[x][y], k);
}
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 x, y;
cin >> x >> y;
if (d[x][y] > INF / 2) cout << "impossible" << endl;
else cout << d[x][y] << endl;
}
return 0;
}
Kruskal算法O(mlogm)
思路
- 将所有边按权重从小到大排序
- 枚举每条边a,b权重c
- if a, b两点不连通
将a, b边加入集合中
- if a, b两点不连通
注意:枚举每条边的操作是并查集操作。
需要使用变量cnt来记录加进集合的边数,若cnt < n - 1
表示不能遍历所有点
问题描述
给定一个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≤105,
1≤m≤2∗105,
图中涉及边的边权的绝对值均不超过1000。
输入样例:
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例:
6
代码
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1000010;
int n, m;
int p[N];
struct Edge
{
int a, b, w;
bool operator< (const Edge &W)const
{
return w < W.w;
}
}edges[N];
int find(int x)
{
if (x != p[x]) p[x] = find(p[x]);
return p[x];
}
int main()
{
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
p[i] = i;
for (int i = 0; i < m; ++i)
{
int a, b, w;
cin >> a >> b >> w;
edges[i] = {a, b, w};
}
sort(edges, edges+m);
int ans = 0, cnt = 0;
for (int i = 0; i < m; ++i)
{
int a = find(edges[i].a);
int b = find(edges[i].b);
if (a != b){
p[a] = b;
ans += edges[i].w;
cnt ++;
}
}
if (cnt < n - 1) cout << "impossible";
else cout << ans << endl;
return 0;
}
Prime算法O(n^2)
思路
dist[i]
距离设置为无穷大
s:当前已经在连通块中的所有点
for i 1…n
(1)t 找到集合外距离最近的点 总共O(n^2)次
(2)st 对该店进行标记
(3)用t更新其他点到集合的距离
dist[1] = 0
问题描述
给定一个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≤105,
图中涉及边的边权的绝对值均不超过10000。
输入样例:
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例:
6
代码
#include <iostream>
#include <cstring>
using namespace std;
int n, m;
const int N = 510, INF = 0x3f3f3f3f;
int g[N][N];
int st[N];
int dist[N];
int prime()
{
int ans = 0;
memset (dist, 0x3f, sizeof dist);
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 (i && dist[t] == INF) return INF;
if (i) ans += dist[t];
st[t] = true;
for (int j = 1; j <= n; ++j)
{
dist[j] = min(dist[j], g[t][j]);
}
}
return ans;
}
int main()
{
cin >> n >> m;
memset(g, 0x3f, sizeof g);
while (m -- )
{
int x, y, c;
cin >> x >> y >> c;
g[x][y] = g[y][x] = min(g[x][y], c);
}
int t = prime();
if (t == INF) cout << "impossible" << endl;
else cout << t << endl;
return 0;
}