最短路
朴素Dijkstra算法
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510;
int n, m;
int g[N][N];// 邻接矩阵
int dist[N];// dist[]距离
bool st[N];// st[]距离是否已经确定
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);// 将所有的距离初始化为无穷
dist[1] = 0;// 结点1的距离初始化为0
for (int i = 0; i < n; i ++ )// 循环n-1次,因为有n个节点,要更新n-1次距离
{
// 找最小值节点t,找所有没被确定的点的距离节点1距离最近的节点
int t = -1;// t = -1 表示还没有确定节点是哪个
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))// 如果j的点的距离未定下来且 当前这个t不是最短的
t = j;
st[t] = true;// 用一个节点更新完与之相连的所有节点后,这个点的值就算作确定下来了
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
}
if (dist[n] == 0x3f3f3f3f) return -1;// 第1个结点到第n个结点的距离正无穷,说明不存在这条路径,返回-1
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);// 本题存在重边
}
int t = dijkstra();
printf("%d\n", t);
return 0;
}
堆优化版的Dijkstra算法
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 100010;
typedef pair<int, int> PII;
int n, m;
int h[N], w[N], e[N], ne[N], idx;// w[]存储权重
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx ++ ;
}
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;// 如果当前点被更新过
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});// 更新成功,放入队列
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);// 邻接表存在重边也无所谓
}
int t = dijkstra();
printf("%d\n", t);
return 0;
}
Bellman-Ford算法
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510, M = 10010;
int n, m, k;
int dist[N], backup[N];
struct Edge// 结构体存储所有边
{
int a, b, w;// a起点b终点w权重
}edges[M];
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++ )// 不超过k条边
{
memcpy(backup, dist, sizeof dist);// 备份
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
dist[b] = min(dist[b], backup[a] + w);
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i ++ )
{
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
edges[i] = {a, b, w};
}
int t = bellman_ford();
if (t == -1) puts("impossible");
else printf("%d\n", t);
return 0;
}
求最短路
// 在堆优化版的Dijkstra算法的基础上修改
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;// 邻接表存储,w[]存储权重
int dist[N];// 记录从节点1到节点i的最短路
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx ++ ;
}
int spfa()
{
memset(dist, 0x3f, sizeof dist);// 0x3f代表16进制数3F
dist[1] = 0;
queue<int> q;
q.push(1);// 结点1为图中第一个点且1到其本身的最短路已知,即为0,将1入队
st[1] = true;// 入队将节点标记为true
while (q.size())// 队列不空
{
int t = q.front();
q.pop();
st[t] = false;// 出队将节点标记为false
for (int i = h[t]; i != -1; i = ne[i])// 将与节点t有边相连的节点j进行遍历
{
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;
}
}
}
}
// 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if (t == -1) puts("impossible");
else printf("%d\n", t);
return 0;
}
判断负环
// 在SPFA算法的基础上修改
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N], cnt[N];// 维护一个cnt[N]数组,记录某个节点到源点最短路所需的边数
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx ++ ;
}
int spfa()
{
// 不用初始化,求的是是否存在负环,不是求距离
queue<int> q;
for(int i = 1; i <= n; i ++ )// 所有点压入队列作为初始点集
{
st[i] = 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;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
if (spfa()) puts("Yes");
else puts("No");
return 0;
}
Floyd算法
#include <iostream>
#include <cstring>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[N][N];
void floyd()
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; k <= n; k ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main()
{
scanf("%d%d%d", &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 a, b, w;
scanf("%d%d%d", &a, &b, &w);
d[a][b] = min(d[a][b], w);// 多条边,保留权值最小的边
}
floyd();
while (Q -- )
{
int a, b;
scanf("%d%d", &a, &b);
if (d[a][b] > INF / 2) puts("impossible");// 存在负权边,比无穷大小一点。d[a][b]==INF会出错。
else printf("%d\n", d[a][b]);
}
return 0;
}
最小生成树
Prim算法
// 朴素版Prim算法,和Dijkstra算法类似
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N];
int dist[N];// 结点到集合的距离
bool st[N];
int prim()
{
memset(dist, 0x3f, sizeof dist);
int res = 0;
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]))// j是集合外的点,当前没有找到任何一个点,j的距离小于当前t的距离
t = j;// 更新t
}
if (i && dist[t] == INF) return INF;// 如果不是第一个点,当前距离最近的点到集合的距离为正无穷(即当前图不连通)
if (i) res += dist[t];// 只要不是第一个点
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
st[t] = true;
}
return res;
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = g[b][a] = min(g[a][b], c);
}
int t = prim();
if (t == INF) puts("impossible");
else printf("%d\n", t);
return 0;
}
Kruskal算法
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 200010;
int n, m;
int p[N];// 并查集p数组
struct Edge
{
int a, b, w;
bool operator< (const Edge &W) const// 重载小于号,按照权重排序
{
return w < W.w;
}
}edges[N];
int find(int x)// 并查集
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i ++ )
{
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
edges[i] = {a, b, w};
}
sort(edges, edges + m);
for (int i = 1; i <= n; i ++ ) p[i] = i;
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) puts("impossible");
else printf("%d\n", res);
return 0;
}