最小生成树：
定义：在一个加权图（即边具有权重或成本的图）中找到一棵包含所有顶点的树，使得这棵树中的所有边的权重之和尽可能小。
题目对应一般是无向图，正负边都没关系
Prim(普利姆算法)：
给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。在图论中，叫做求最小生成树。
它和 Djikstra 算法特别像
朴素版的Prim：
稠密图 稠密图一般用朴素版Prim
时间复杂度最差：O(n^2)
算法流程：
和Djkstra算法非常相似
例题：
题目：
给定一个 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
代码：
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N]; // 存储图
int dist[N]; // 存储各个点到集合的距离
bool st[N]; // true表示在集合里
int prim()
{
memset(dist, 0x3f, sizeof dist); // 初始化
int res = 0; // 最小生成树所有边的权重和
for (int i = 0; i < n; i ++ ) // 迭代n次
{
// 找出集合外距离集合距离最近的点 如果没有比INF小的t保持-1不变
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) res += dist[t];
// 这里先将边加进去因为假如有负环，在用t更新其他点时，当更新到自己时，就是j等于t时，会将自己变小，但是最小生成树不能有环，是不可以的，所以提前累加
st[t] = true; // 将这个点加进集合
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
// 用t更新其他点到集合的距离
}
return res;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
cin >> a >> b >> c;
g[a][b] = g[b][a] = min(g[a][b], c);
}
int t = prim();
if (t == INF) puts("impossible"); // 不连通
else cout << t;
return 0;
}
堆优化版的Prim：
稀疏图 一般不常用
时间复杂度最差：O(mlogn)
Kruskal（克鲁斯卡尔算法）：
稀疏图 稀疏图一般用Kruskal算法
时间复杂度固定：O(mlogm)
算法思路：
1.将所有边按权重从小到大排序 （可以用快排）O(mlogm)
2.枚举每条边 a b 权重是 c，
if a b不连通
将这条边加入集合中
过程示例：
其中判断是否行成回路就用并查集，看边两端的点所在集合的代表元素是否相同，相同则说明是在同一个集合里，因为我们在合并的时候是把一个点的父节点指向另一个点，所以我们递归找到最后会找到代表元素，这个点的父节点是自己，
例题：
题目：
给定一个 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 ≤ 10^5,
1 ≤ m ≤ 2 ∗ 10^5,
图中涉及边的边权的绝对值均不超过 1000。
输入样例：
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例：
6
代码：
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f;
int n, m;
int p[N]; // 存储每个节点的父节点
struct Edge
{
int a, b, w;
bool operator< (const Edge &W)const // 重载小于号
{
return w < W.w;
}
}edges[M];
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
// 找到所在集合的代表元素（根节点），如果这个节点的父节点不是自己，就递归找他的父节点的父节点，直到找到根节点
return p[x];
}
int kruskal()
{
sort(edges, edges + m); // 以升序排序所有边
int res = 0, cnt = 0; // res是最小生成树的所有边权和，cnt是选中的边的数量
for (int i = 0; i < m; i ++ ) // 遍历所有边
{
int a = edges[i].a, b = edges[i].b, w = edges[i].w;
a = find(a), b = find(b);
if (a != b) // 如果连个点所在集合的代表元素(根节点)不同，那就是不同的集合，就选用这条边
{
p[a] = b; // 合并两个集合
res += w; // 选用这条边
cnt ++;
}
}
if (cnt < n - 1) return INF; // 如果选用的边不到n - 1条，说明不连通，没有最小生成树
return res;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) p[i] = i; // 初始化p数组,初始每个节点的父节点都是自己
for (int i = 0; i < m; i ++ )
{
int a, b, w;
cin >> a >> b >> w;
edges[i] = {a, b, w};
}
int t = kruskal();
if (t == INF) puts("impossible");
else cout << t;
return 0;
}二分图：
二分图简单来说就是可以把图中的点分成两边，左边的点只与右边的点相连接，右边的点只与左边的点相连接。 还可以说是把所有点分成两个集合，使所有边只出现在集合之间。
特点：一定不含奇数环，可能包含长度为偶数的环，不一定是连通图，没有奇数环的图一定是二分图
染色法：
深度优先遍历
时间复杂度：O(n + m)
判断一个图是不是二分图
算法思路：
用1表示染白色 用2表示染黑色，则所有边的两个端点应该是一个白色一个黑色，遍历一下每个点，如果未染色则染上黑色或者白色，然后遍历所有和这个点连通的点，染上不同的染色
由于图中不含奇数环，所以染色过程中一定没有矛盾， 如果在染色的途中出现矛盾，则一定不是二分图，如果染色完毕没有矛盾则是二分图
例题：
题目：
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。
请你判断这个图是否是二分图。
输入格式第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示点 u 和点 v之间存在一条边。
输出格式
如果给定图是二分图，则输出 Yes，否则输出 No。
数据范围
1 ≤ n, m ≤ 10^5
输入样例：
4 4
1 3
1 4
2 3
2 4
输出样例：
Yes
代码：
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 100010, M = 200010;
int n, m;
int e[M], ne[M], h[N], idx; // 稀疏图用邻接表存储
int color[N]; // 存储各个点的颜色，0代表没染色，1,2代表不同颜色
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
bool dfs(int u, int c) // 深度优先遍历
{
color[u] = c; // 记录这个点的颜色
for (int i = h[u]; i != -1; i = ne[i]) // 遍历所有和u点相邻的点
{
int j = e[i];
if (!color[j]) // 如果这个点没有染色
{
if (!dfs(j, 3 - c)) return false; // 3 - c意思是点j染的是1，则相邻的点染成2反之染成1，如果遍历途中染色失败，返回false
}
else if (color[j] == c) return false;
// 如果和j相邻这个点染色了，并且染的颜色跟j一样，则冲突，返回false
}
return true; // 如果都没有冲突，返回true
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(h, -1, sizeof h); // 初始化
while (m -- )
{
int a, b;
cin >> a >> b;
add(a, b), add(b, a); // 加边
}
bool flag = true; // false表示染色有冲突
for (int i = 1; i <= n; i ++ ) // 遍历所有点
if (!color[i]) // 如果没有染色
{
if (!dfs(i, 1)) // 就染上1，并且dfs
{
flag = false; // 遍历这个点相邻的点时出现矛盾的话就false
break;
}
}
if (flag) puts("Yes");
else puts("No");
return 0;
}匈牙利算法：
时间复杂度最坏:O(mn) 实际运行时间一般远小于O(mn)
匈牙利算法准则：待字闺中，据为己有；名花有主，求他放手。(看别人说的（→_→） ）
概念：
匹配：在图论中，“匹配”指的是一个边的集合，其中没有两条边共享同一个顶点。换句话说，匹配是由图中一些边组成的子集，使得每条边都不相邻（即没有公共的顶点）
最大匹配：在一个图中，最大匹配是指包含尽可能多的边的匹配。也就是说，没有更大的匹配可以包含更多的边。
完美匹配：如果一个匹配包含了图中的所有顶点（即每个顶点恰好出现在一条边中），那么这个匹配被称为完美匹配。
算法思路：
给定一个二分图，让求最大匹配
例题：
题目：
给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。
数据保证任意一条边的两个端点都不可能在同一部分中。
请你求出二分图的最大匹配数。
二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。
二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。
输入格式
第一行包含三个整数 n1、 n2 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。
输出格式
输出一个整数，表示二分图的最大匹配数。
数据范围
1 ≤ n1, n2 ≤ 500,
1 ≤ u ≤ n1,
1 ≤ v ≤ n2,
1 ≤ m ≤ 10^5
输入样例：
2 2 4
1 1
1 2
2 1
2 2
输出样例：
2
代码：
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 510, M = 100010;
int n1, n2, m;
int h[N], e[M], ne[M], idx; // 邻接表
int match[N]; // match[j] = k 表示女孩j的配对男友是k
bool st[N]; // 预定数组 简单来说st的作用就是，避免女生j的现男友k去找备胎的时候，又去找到这个j
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
//递归找匹配
int find(int x)
{
for (int i = h[x]; i != -1; i = ne[i]) // 遍历这个男生有好感的所有女生
{
int j = e[i];
if (!st[j]) // 这一轮匹配中如果这个女孩没被预定
{
st[j] = true; // 这个女孩就被预定了 就是我先预定着，如果之前和这个女生配对着的男生可以换人，那我这个预定就可以变成配对了
// 如果这个女孩没有配对的男友或者 她的男朋友能不能预定其他有好感的女生
if (match[j] == 0 || find(match[j]))
{
match[j] = x; // 配对
return true;
}
}
}
// 有好感的全都配对了，失败
return false;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n1 >> n2 >> m;
memset(h, -1, sizeof h);
while (m -- )
{
int a, b;
cin >> a >> b;
add(a, b); // 因为只需要从一边找另一边，所以尽管是无向图，但存一个方向就行了
}
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st);
if (find(i)) res ++;
}
cout << res;
return 0;
}
扫一扫
2731
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
