[算法笔记]基础图论总结一（最短路、最小生成树、拓扑排序）
零、基础：
1、图的存储方式：
1）、邻接表：
vector<int> h(n, -1); // 邻接表表头指针
vector<int> ne(n); // next指针
vector<int> e(n); // value
vector<int> w(n); // 边的权值，有时不需要
int idx = 0; // 结点的全局标识符
// 1、增加一条边
void add(int a, int b, int c) {
ne[idx] = h[a], e[idx] = b, w[idx] = c, h[a] = idx++;
}
// 2、遍历与t点相连的所有边
for (int i = h[t]; i != -1; i = ne[i]) {
int j = e[i];
// t, j就是相连的两个点
}
2）、邻接矩阵：
vector<vector<int>> g;
// 1、初始化
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) g[i][j] = 0;
else g[i][j] = 1e8;
}
}
// 2、增加一条边
g[i][j] = w;
// 3、遍历t点所有边
// 邻接矩阵无法记住相邻关系，所有只有全部遍历
for (int i = 0; i < n; i++) {
cout << g[t][i];
}
3）、结构体：
有些算法（例如Bellman-Ford算法）不一定需要将图完整表示出来，我们只关注边的信息
struct Edge {
int from, to, w;
bool operator< (const Edge& e) const {
return w < e.w;
}
}
一、最短路算法：
1、Dijkstra算法：
int dijkstra(...) {
vector<int> dist(n, 1e8); // 距离起点的距离
vector<bool> vis(n, false); // 是否确定了最短路径
priority_queue<PII, vector<PII>, greater<>> q; // 优先队列，确定离起点最近的非树结点
dist[0] = 0;
q.push({0, 0}); // {dist[i], i}，dist置于pair第一维，用于排序
while (!q.empty()) {
int t = q.top().second;
q.pop();
if (!vis[t]) {
// 遍历结点，根据图的不同存储方式，有两种形式，参考上文，这里使用邻接表形式
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];
q.push({dist[j], j});
}
}
vis[t] = true;
}
}
return dist[n - 1];
}
2、朴素Bellman-Ford算法：
- 朴素Bellman-Ford算法效率较低，但是有一个特别的应用场景：有边数限制的最短路算法，假设边数限制为k。
- Bellman-Ford只关注边，因此选用上述结构体方式存图。
vector<Edge> edges; // 图已建好
int bellman_ford(...) {
vector<int> dist(n, 1e8);
dist[0] = 0;
for (int i = 0; i < k; i++) {
auto last = dist; // 必须使用上一次的dist，因为这一轮的dist可能被更新
for (auto& edge : edges) {
auto [a, b, c] = edge;
dist[b] = min(dist[b], last[a] + c);
}
}
if (dist[n - 1] >= 1e8 / 2) return -1; // 不直接判断相等是因为在权值为负情况下，有可能会被更新
return dist[n - 1];
}
3、SPFA算法（队列优化Bellman-Ford算法）：
- 优化思路：假设源点s到点b之间有点a，当dist[a]没有被更新时，dist[b]更新没有意义。
- 由于使用队列，需要表示点，因此这里选择邻接表。还需要一个数组inQue表示是否在队列中。
- SPFA与Dijkstra一样使用数组标识一个结点的状态，不同的是：前者表示是否在队列中，因此每次往队列中加入元素j时，inQue[j] = true; 后者表示该点最小路径是否确定，因此必须是t结点被pop出时确定。
int spfa(...) {
vector<int> dist(n, 1e8);
vector<bool> inQue(n, false);
queue<int> q;
dist[0] = 0;
q.push(0);
inQue[0] = true;
while (!q.empty()) {
int t = q.front();
q.pop();
inQue[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 (!inQue(j)) {
q.push(j);
inQue[j] = true;
}
}
}
}
if (dist[n - 1] >= 1e8 / 2) return -1; // 不直接判断相等是因为在权值为负情况下，有可能会被更新
return dist[n - 1];
}
- Bellman-Ford算法还有一个应用，一般用SPFA来写，即判断负权环是否存在。只要在上述代码上做些修改即可。
bool spfa(...) {
vector<int> dist(n, 1e8);
dist[0] = 0;
vector<int> cnt(n); // 从源点到点x的边数
// 为了防止负权环并不在 点0 ~ 点n-1的路径上，把所有点都加入队列中
for (int i = 0; i < n; i++) {
q.push(i);
inQue[i] = true;
}
while (!q.empty()) {
int t = q.front();
// ...
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 (!inQue(j)) {
// ...
}
}
}
}
return false
}
4、Floyd算法：
-
Floyd算法一般用来求多源最短路径，即可以求图中任意两点的最短路径。
-
使用邻接矩阵，类似于动态规划
void floyd() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j])
}
}
}
}
二、最小生成树算法：
1、Prim算法：
- 类似于Dijkstra算法，实际上Dijkstra也再次发现了Prim算法。
- Prim算法每次将非最小生成树中的dist最小点加入最小生成树，Dijkstra算法将非最短路径树的最小点加入最短路径树。
- 基于邻接表实现的时间复杂度在边非常多时容易TLE，这里给出邻接矩阵实现方式。
int prim() {
vector<int> dist(n, 1e8); // 距离起点的距离
vector<bool> vis(n, false); // 是否确定了最短路径
int res = 0;
dist[0] = 0;
for (int i = 0; i < n; i++) {
int t = -1;
// 遍历所有节点，找到距离生成树集合最近的节点
for (int j = 0; j < n; j++) {
if (!vis[j] && (t == -1 || dist[j] < dist[t])) {
t = j;
}
}
// 不存在可以加入最小生成树的点，直接返回false
if (dist[t] == 1e8) return -1;
res += dist[t];
vis[t] = true;
// 松弛操作
for (int j = 0; j <= n; j++) {
dist[j] = min(dist[j], g[t][j]);
}
}
return res;
}
2、Kruskal算法：
- 基于并查集实现。
vector<int> p(n);
int find(int x) {
return x == p[x] ? x : (p[x] = find(p[x]));
}
// 对m条边进行排序，每次取最小边加入最小生成树
Edge edges[m];
int kruskal() {
// res：最小生成树代价，cnt：最小生成树中节点个数，如果最后小于n，则返回-1
int res = 0, cnt = 0;
sort(edges, edges + m);
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < m; i++) {
int a = edges[i].from, b = edges[i].to, c = edges[i].w;
a = find(a), b = find(b);
// 如果两个点不属于一个连通分量中，则加入最小生成树
if (a != b) {
p[a] = b;
res += c;
cnt++;
}
}
if (cnt < n - 1) return -1;
return res;
}
三、拓扑排序：
- 基本要点很简单，首先存图，接着将所有点放入优先队列中，取出队头入度为0的节点，所有与该节点相连的节点的入度--。不断重复该操作。
- 但是需要注意的是，在STL自带优先队列中动态更改值比较麻烦。因此我们需要每次手动遍历寻找ind为0的节点，因此使用普通的queue，甚至数组都是可以的，这里我们使用模拟队列。
// 邻接表存图
// 每个点的入度
int h[N], ne[M], e[M], ind[N], idx;
void add(int a, int b) {
// b节点入度++
ne[idx] = h[a], e[idx] = b, ind[b]++, h[a] = idx++;
}
bool top_sort() {
// 模拟队列
int q[N], hh = 0, tt = -1;
for (int i = 0; i < n; i++) {
if (!ind[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];
ind[j]--;
if (!ind[j]) {
q[++tt] = j;
}
}
}
// 队列中应包含所有节点
return tt == n - 1;
}
