图论问题概述总结
对于**图论**，我们尊熟悉的算法是比较多的，这次，我就找了集中常用的算法。
## 几种算法
1. **最短路**算法（Dijkstra,SPFE,FLOYD）
- Dijkstra单源最短算法
首先，此算法适用于计算一个点到另一个点的最短路径，且算法绝对不能出现负环。这个算法的速度慢，只用于接觉小规模的问题，如图：
这个图就是求算法的基本思路。算法过程：
- 从节点上找到最近点那个节点，将他标记，加入集合U。
- 将定点U连出边的邻点相连接，不在集合U中寻找。
- 重复前面的操作，用来指导V=U是，查找结束，最后结束流程。
本算法的算法流程图：
https://wenku.baidu.com/view/8a5c11303968011ca300916a.html
参考代码：
```
#include <iostream>
#include <cstring>
using namespace std;
const int N = 1e3 + 9;
const int M = 1e4 + 9;
const int inf = 0x3f3f3f3f;
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[M << 1];
int head[N], len;
void init() {
memset(head, -1, sizeof head);
len = 0;
}
void add(int u, int v, int w) {
e[len] = edge(v, w, head[u]);
head[u] = len++;
}
void add2(int u, int v, int w) {
add(u, v, w);
add(v, u, w);
}
int n, m;
int dis[N];
bool vis[N];
void dijkstra(int u) {
memset(vis, false, sizeof vis);
memset(dis, inf, sizeof dis);
dis[u] = 0;
for (int i = 0; i < n; ++i) {
int mi = inf;
for (int j = 1; j <= n; ++j) {
if (!vis[j] && dis[j] < mi) {
mi = dis[u = j];
}
}
if (mi == inf) {
return;
}
vis[u] = true;
for (int j = head[u]; ~j; j = e[j].next) {
int v = e[j].v;
int w = e[j].w;
if (!vis[v] && dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
}
}
}
}
int main() {
init();
int u, v, w;
cin >> n >> m;
while (m--) {
cin >> u >> v >> w;
add2(u, v, w);
}
dijkstra(1);
cout << dis[n] << endl;
return 0;
}
```
这只是一个基本的流程代码，你可在刷掉模板的基础上，在进行修改。
**它的基本思想是以起始点为中心往外层扩展（广度优先搜索+贪心），直到扩展到终点为止。**
这就是我们的算法，因此，可以解决很多问题。
```
3 3
1 2 5
2 3 5
3 1 2
```
输入数据，看看会怎么样！
-堆优化Dijkstra
正对于稀疏图的算法，我们用与优化。
```
#include <iostream>
#include <cstring>
#include <set>
using namespace std;
const int N = 1e3 + 9;
const int M = 1e4 + 9;
const int inf = 0x3f3f3f3f;
typedef pair<int, int> pall;
#define X first
#define Y second
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[M << 1];
int head[N], len;
void init() {
memset(head, -1, sizeof head);
len = 0;
}
void add(int u, int v, int w) {
e[len] = edge(v, w, head[u]);
head[u] = len++;
}
void add2(int u, int v, int w) {
add(u, v, w);
add(v, u, w);
}
int n, m;
int dis[N];
bool vis[N];
void dijkstra(int u) {
memset(vis, false, sizeof vis);
memset(dis, inf, sizeof dis);
dis[u] = 0;
}
int main() {
init();
int u, v, w;
cin >> n >> m;
while (m--) {
cin >> u >> v >> w;
add2(u, v, w);
}
dijkstra(1);
cout << dis[n] << endl;
return 0;
}
```
找最小值，这里是和普通 Dijkstra 的核心不同之处，我们只需要获取堆顶元素即可（堆自动实现排序，
堆顶元素就是我们需要的最小值）。然后我们把这个元素加入集合（标记就是加入集合的意思）。
- SPFA单源最短路算法
在 SPFA 算法中，使用 di表示从源点到顶点 i的最短路，额外用一个队列来保存即将进行拓展的顶点
列表，并用ingi 来标识顶点 i是不是在队列中。
如图：
SPFA 的空间复杂度为O(V),有点像这个稀疏图的步揍。他用队列来运行，因此，SPEA只是是在对列上升级以下，并不是那种十分多的。**在一定程度上，可以认为 SPFA 是由 BFS 的思想转化而来。从不含边权或者说边权为 个单位长度的图上的 BFS，推广到带权图上，就得到了 SPFA。**
算法步揍：
- 用一个队列来保存多个扩展的队列。
- 用一个队列中取的一个元素，并且对其他点进行松弛。
- 当所有不在队列的点都入了队列，则程序结束，算法进行完毕。
```
bool inq[MAX_N];
int d[MAX_N]; // 如果到顶点 i 的距离是 0x3f3f3f3f，则说明不存在源点到 i 的最短路
void spfa(int s) {
memset(inq, 0, sizeof(inq));
memset(d, 0x3f, sizeof(d));
d[s] = 0;
inq[s] = true;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = false;
for (int i = p[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (d[u] + e[i].w < d[v]) {
d[v] = d[u] + e[i].w;
if (!inq[v]) {
q.push(v);
inq[v] = true;
}
}
}
}
}
```
算法的图：https://i.loli.net/2019/06/09/5cfcb3db1267062487.jpg
上面的代码就是SPEA的全部结构，初始化与第一个算法一样的结构一样的。
**判断负环**的SPEA算法：
```
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 1e3 + 9;
const int M = 1e4 + 9;
const int inf = 0x3f3f3f3f;
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[M << 1];
int head[N], len;
void init() {
memset(head, -1, sizeof head);
len = 0;
}
void add(int u, int v, int w) {
e[len] = edge(v, w, head[u]);
head[u] = len++;
}
void add2(int u, int v, int w) {
add(u, v, w);
add(v, u, w);
}
int n, m;
int main() {
init();
int u, v, w;
cin >> n >> m;
while (m--) {
cin >> u >> v >> w;
add2(u, v, w);
}
return 0;
}
```
接下来就可以运行程序了：
```
3 3
1 2 5
2 3 5
3 1 2
```
- Floyd 多源最短路算法
Floyd 算法是一种计算给定的带权图中任意两个顶点之间最短路径的算法。相比于重复执行多次单源最
短路算法，Floyd 具有高效、代码简短的优势，在解决图论最短路题目时比较常用。
**floyd 算法是解决负环（可以计算出任意两点之间的最短路）有向图或无向图的多源最短路问题。常
用邻接矩阵存储，算法的时间复杂度 O(N2)，空间复杂度O(N2) 。**
算法方式：
- 如果不经过第 个点，那么就是 dp[k-1][i][j]。
- 如果经过第 个点，那么就是 dp[k-1][i][j]+dp[k-1][i][j]。
所以就变成了：
```
dp[k][i][j] = min(dp[k − 1][i][j], dp[k − 1][i][k] + dp[k − 1][k][j])
```
所以就变成了如下的代码：
```
int g[N][N]; // 邻接矩阵存图
int dp[N][N][N];
void floyd(int n) {
for (int k = 0; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (k == 0) {
dp[k][i][j] = g[i][j];
} else {
dp[k][i][j] = min(dp[k - 1][i][j], dp[k - 1][i][k] + dp[k - 1][k][j]);
}
}
}
}
}
```
我们写出最终的 Floyd 的形式，这也是常用的写法，优化了一维的空间。并且写法更加简单。这里要注
意，枚举的中间点 一定要写在最外面。没有注意这一点，很容易把 3 个循环的顺序弄错了，那么结
果也就是错的。
刚才的分析得出：
```
int g[N][N];
void floyd(int n) {
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
}
```
算法到这里就完成了，接下来给大家介绍**差分约束系统**。
- 差分约束系统
我们在求解差分约束系统时，可以将其转化为图论中单源最短路（或最长路）问题。
途中有负环是，就可以这样。
```
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 1e3 + 9;
const int M = 1e4 + 9;
const int inf = 0x3f3f3f3f;
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[M << 1];
int head[N], len;
void init() {
memset(head, -1, sizeof head);
len = 0;
}
void add(int u, int v, int w) {
e[len] = edge(v, w, head[u]);
head[u] = len++;
}
void add2(int u, int v, int w) {
add(u, v, w);
add(v, u, w);
}
int n, m;
int dis[N], in[N];
bool vis[N];
bool spfa(int u) {
memset(vis, false, sizeof vis);
vis[u] = true;
memset(dis, -1, sizeof dis);
dis[u] = 0;
memset(in, 0, sizeof in);
in[u] = 1;
queue<int> q;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
vis[u] = false;
for (int j = head[u]; ~j; j = e[j].next) {
int v = e[j].v;
int w = e[j].w;
if (dis[v] < dis[u] + w) { // 求最长路，和求最短路相反
dis[v] = dis[u] + w;
if (!vis[v]) {
q.push(v);
vis[v] = true;
++in[v];
if (in[v] > n + 1) {
return true;
}
}
}
}
}
return false;
}
int main() {
init();
int u, v, w, op;
cin >> n >> m;
while (m--) {
cin >> op;
cin >> u >> v >> w;
}
if (op == 1) {
add(u, v, -w);
}else if (op == 2) {
add(v, u, w);
}else {
add(u, v, -w);
add(v, u, w);
}
for (int i = 1; i <= n; ++i) {
add(0, i, 0);
}
if (spfa(0)) {
cout << "no" << endl;
}else {
for (int i = 1; i <= n; ++i) {
cout << "x" << i << " = " << dis[i] << endl;
}
}
return 0;
}
```
这就是差分约束，现在运行你的程序：
```
4 3
1 1 2 3
2 3 2 2
3 3 4 1
```
~~点个赞呗~~
**本期图论结束，下期再见！**