// 树是特殊的图（无环联通图）
// 添加一条边
int h[N], e[N], ne[N], idx;
/*
插入前
a --> y
dfs时，含义
e[idx] = b; // (a节点所有出边对应的节点是e[idx])
ne[idx] = h[a]； // 出边idx对应的链表尾方向的下一条出边是ne[idx]
h[a] = idx++; // a节点的最后一条出边是h[a]；
*/
// 在a对应的邻接表里面插入节点b
/*
1. idx是新插入的节点，先给节点赋值；
2. 新来的节点指向的地址；
3. 头插法指向新节点；
*/
void add(int a, int b)
{
// idx是链表节点的地址
// 头插法
e[idx] = b; // idx地址对应的节点存3；
ne[idx] = h[a]； // idx的下一个地址是h[a]
h[a] = idx++; // 头节点指向新节点的地址idx
}
// 初始化
idx = 0;
memset(h, -1, sizeof h);
void dfs(int u)
{
if st[u] return;
for (int i = h[a]; i != -1; i = ne[i])
{
int j = e[i];
dfs(j)
}
}
// bfs
// 有向无环图，拓扑图；
// 拓扑序列：把一幅图拉平，边的所有箭头的方向都一致；
// 后序遍历的结果反转就是拓扑排序的结果；
// 时间复杂度 O(n+m), n 表示点数，m 表示边数
bool topsort()
{
int hh = 0, tt = -1;
// d[i]存储i的入度
for (int i = 1; i <= n; i++)
if (!d[i])
q[++tt] = i;
while (hh <= tt)
{
int t = q[hh++];
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (--d[j] == 0)
q[++tt] = j;
}
}
// 如果所有点都入队列了，说明存在拓扑排序
return tt == n - 1;
}
// 朴素Dijkstra
/**
步骤：
1. 找到当前未被标识，且离源点最近的点t；
2. 对t点进行标识；
3. 用t点更新其他点的距离；
*/
int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 每个点的最短路径是否被确认
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < n - 1; i++)
{
int t = -1;
for (int j = 1; j <= n; j++)
{
if (!st[j] && (t == -1 && dist[t] > dist[j]})
{
t = j;
}
// t来更新所有其他点的距离
for (int j = 1; j <= n; j++)
{
dist[j] = min(dist[j], dist[t] + g[t][j]);
}
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
}
// 堆优化版dijkstra
/*
时间复杂度：O(mlogn),n是点数，m是边数
b
1 / \ 2
a -- --> c
4
*/
typedef pair<int, int> PII; // first距离，second节点编号
int n;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j], j});
}
}
}
}
// Bellman-ford算法
/*
步骤：
1. 循环n，进行n-1次松弛操作；
2. 遍历所有边，所有边进行松弛操作；
3. n-1次松弛操作后还能更新，则存在负环；
三角不等式： dist[b] <= dist[a] + w;
负权回路：在n-1次松弛后还能更新，说明存在负环；
串联效应：第k次迭代，是从第k-1步的状态，转向k步的状态，而串联指的是，在第k次迭代的中途，d[]中部分数据已经发生了迭代（k次状态），迭代后得到k+1次的状态；
// 两重循环， 第二重循环，遍历m条边；
for k 次 // 1号点到n号点，最多经过k条边的最短路径
for 所有边 a, b, w a >> b
dist[b] = min(dist[b], dist[a] + w); // 松弛操作；
*/
// spfa算法
/*
队列优化bellmann-Ford算法
*/
const int N = 10000;
int n;
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N];
bool st[N]; // 邻接表是否在队列中
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
// spfa算法判断负环
统计每个点的最短路径中所包含的边数，如果某点的最短路径所包含的变数大于等于n，则说明包含负环；
bool spfa()
{
queue<int> q;
for (int i = 1; i <= n; i ++ )
{
st[i] = true; // 在队列中，则为true;
q.push(i);
}
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1; // 统计最短路径的边数
if (cnt[j] >= n) return true;
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/48499/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
// 朴素版本prim算法
/*
int dist[n]； # 存储各节点到生成树的距离
int state[n]； # 节点是否加入到生成树
int pre[n]; # 节点的前去节点
dist[1] = 0;
for (int i = 0; i < n; i++)
t <- 没有联通起来，但距离联通部分最近的点；
state[t]=1;
更新dist和pre；
用t更新其他点到集合的距离
*/
Kruskal算法最小生成树
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);
for (int i = 1; i <= n; i++) p[i] = i; // 初始化并查集
int res = 0, cnt = 0;
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;
return res;
}
染色法判别二分图
定义：二分图的顶点可以划分为两个互不相交的子集，图中每条边依附的两个顶点分属于这两个子集，且子集内顶点互不相邻。
时间复杂度是O(n + m)， n表示点数，m表示边数
步骤：
1. 0白色，1黑色，-1初始值；
2. dfs(u, c)：将u点染成c颜色，通过宽度优先搜索，看是否有冲突；
3. 遍历所有节点执行dfs；
const int N = 1e5 + 10, M = 2e5 + 10;
int n, m
int h[N], e[M], ne[M], idx; // e[N], ne[N] 报超时错误
int color[N];
// 参数：u表示当前节点，c表示当前节点颜色
bool dfs(int u, c)
{
color[u] = c;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (color[j] == -1)
{
if (!dfs(j, !c)) return false;
}
else if (color[j] == c) return false;
}
return true;
}
bool check()
{
memset(color, -1, sizeof color);
bool flag = true;
for (int i = 1; i <= n; i++)
if (color[i] == -1)
if (!dfs[i], 0)
{
flag = false;
break;
}
return flag;
}
匈牙利算法
二分图的最大匹配
步骤：
1. 第一个集合为男生，第二个集合为女生；
2. find(x)函数作用：如果渣男x来模拟配对，会不会使得匹配增多；
3. find(x)的实现：x相邻的妹子为j，如果j没有男友，或者j的原男友能够找到其他喜欢的妹子，则x和j匹配成功；
int n1, n2;
int h[N], e[M], ne[M], idx;
int match[N]; // 第二个集合中的点对应第一个集合中的哪个
bool st[N];
// 如果x来参与模拟配对，会不会使得匹配增多；
bool 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] || find(match[j])) // 如果j没有男友，或者原男友能够预定其他喜欢的女孩，则j配对成功，更新match；
{
match[j] = x;
return true;
}
}
}
retrn false;
}
// 求最大匹配数，依次枚举第一个集合中的每个点，能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i++)
{
memset(st, false, sizeof st);
if (find(i)) res ++;
}
扫一扫
936
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
