目录
Dijkstra
n<m时未优化算法更快（n*n+m）< ((n+m)log n))
Dijkstra模板
#include<bits/stdc++.h>
using namespace std;
const int N = 1e7;
struct Node {
int y, v;
Node(int _y, int _v) { y = _y, v = _v; }
};
vector<Node>edge[N + 1];
int n, m, dist[N + 1];
bool b[N + 1];
int Dijkstra(int s, int t) {
memset(b, 0, sizeof(b));
memset(dist, 127, sizeof(dist));
dist[s] = 0;
while (1) {
int x = -1;
for (int i = 1; i <= n; i++) {
if (!b[i] && dist[i] < 1 << 30)
if (x == -1 || dist[i] < dist[x])
x = i;
}if (x == t || x == -1)break;//找不到点加入集合C 结束
b[x] = 1;
for (auto i : edge[x])
dist[i.y] = min(dist[i.y], dist[x] + i.v);
}return dist[t];
}#include<bits/stdc++.h>
using namespace std;
const int N = 1e7;
struct Node {
int y, v;
Node(int _y, int _v) { y = _y, v = _v; }
};
set<pair<int, int>>q;
vector<Node>edge[N + 1];
int n, m, dist[N + 1];
int Dijkstra(int s, int t) {
memset(dist, 127, sizeof(dist));
dist[s] = 0; q.clear();
for (int i = 1; i <= n; i++)
q.insert(make_pair(dist[i], i));
while (!q.empty()) {
int x = q.begin()->second;
q.erase(q.begin());
if (x == t || dist[x] > 1 << 30)break;//找不到点加入集合C 结束
for (auto i : edge[x]) {//松弛操作更新
if (dist[x] + i.v < dist[i.y]) {
q.erase(make_pair(dist[i.y], i.y));
dist[i.y] = dist[x] + i.v;
q.insert(make_pair(dist[i.y], i.y));
}
}//dist[i.y] = min(dist[i.y], dist[x] + i.v);
}return dist[t];
}eg：
给你一张简单有向图，边权都为非负整数。以及一些询问，询问两个点之间的距离。
图用以下形式给出：
第一行输入三个整数 n,m,k，表示图的顶点数、边数和询问次数，顶点编号从 1到 𝑛。
接下来 m 行，每行三个整数 x,y,z，表示 x 到 y 有一条有向边，边权为 z。
接下来 k 行，每行两个整数 x,y，询问从 x到 y 的最短路长度，如果无法到达，输出 −1。
输入格式
第一行三个整数 n,m,k，表示图的顶点数、边数和询问次数。
接下来 m 行，每行有三个整数，代表一条边。
接下来 k 行，每行有两个整数，代表一次询问。
输出格式
输出共 k 行，每行一个数表示一次询问的答案。
样例输入
3 3 2
1 2 3
2 3 2
3 2 1
1 3
3 1样例输出
5
-1数据规模
对于所有数据，保证 2 ≤ n ≤ 5000, 0 ≤ m ≤ 10000, 1≤ k ≤5, 1 ≤ x,y ≤ n,x≠y,1 ≤ z ≤ 10000
#include<iostream>
#include<vector>
#include<string.h>
using namespace std;
struct Node {
int y, v;
Node(int _y, int _v) {
y = _y, v = _v;
}
};
vector<Node>edge[5001];
int n, m, k, s, t, dist[5001];
bool b[5001];
void dijkstra(int s, int t) {
memset(dist, 127, sizeof(dist));
memset(b, false, sizeof(b));
dist[s] = 0;
while (1) {
int x = -1;
for (int i = 1; i <= n; i++) {//找V-S中最小距离的点 将其加入S
//cout << 'i' << i << endl;
if (!b[i] && dist[i] < 1 << 30) {//遍历所有点找V-S中的且距离小于正无穷的点
if (x == -1 || dist[x] > dist[i])//最开始还没找到一个点或找的点距离小于已找到点x
{
x = i;//更新点x，将x加入S
//cout<<'x'<<x<<" dist"<<dist[x]<<endl;
}
}
}//cout<<"x:"<<x<<" t:"<<t<<endl;
b[x] = 1;
if (x == t || x == -1)break;//如果当前x即为终点t或V中找不到终点t跳出循环
for (int i = 0; i < edge[x].size(); i++) {//加入S后 更新dis[V-S]的值
//cout<<"start1";
Node t = edge[x][i];
if (!b[t.y]) {
dist[t.y] = min(dist[t.y], dist[x] + t.v);
//cout<<t.y<<dist[t.y]<<endl;
}
}//cout<<"start";
}//cout<<dist[t]<<endl;
if (dist[t] < 1 << 30)
printf("%d\n", dist[t]);
else printf("-1\n");
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
int x, y, z;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
edge[x].push_back(Node(y, z));
}
for (int i = 1; i <= k; i++) {
scanf("%d%d", &s, &t);
dijkstra(s, t);
}
return 0;
}Floyd
空间复杂度O(n^3)->O(n^2)
Floyd模板
#include<bits/stdc++.h>
using namespace std;
const int N = 300;
int n, m, q, f[N+1][N+1];
void Floyd() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (f[i][k] < 1 << 30 && f[k][j] < 1 << 30)//判断两点之间是否有路径
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
memset(f, 127, sizeof(f));//初始最大化 点到点距离无限大
//确保任意点之间都有边时不需要 同理不需要f[i][i]=0;
for (int i = 1; i <= n; i++)
f[i][i] = 0;//自己到自己距离为0
int x, y, z;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
f[x][y] = z;//有向边距离初始化
}
Floyd();
return 0;
}eg1：
数据范围：
2 ≤ n ≤ 300, 0 ≤ m ≤ 20000, 1 ≤ k ≤ 100000, 1 ≤ x,y ≤ n,x≠y, 1 ≤ z ≤ 10000
#include<bits/stdc++.h>
using namespace std;
const int N = 300;
int n, m, q, f[N+1][N+1];
void Floyd() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (f[i][k] < 1 << 30 && f[k][j] < 1 << 30)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
memset(f, 127, sizeof(f));//初始最大化 点到点距离无限大
for (int i = 1; i <= n; i++)
f[i][i] = 0;//自己到自己距离为0
int x, y, z;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
f[x][y] = z;//有向边距离初始化
}
Floyd();
int s, t;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &s, &t);
if (f[s][t] < 1 << 30)printf("%d\n", f[s][t]);
else printf("-1\n");
}
return 0;
}eg2:删点游戏
给你一张简单有向图，我们要把所有点依次删完。小蜗每次会删掉图中的一个点和所有与它相连的边，小蜗想知道每删去一个点之后图中所有点对的距离之和。
图用以下形式给出：
第一行输入一个数 n, 表示顶点数。
接下来 n𝑛 行，会输入一个 n∗n 的矩阵 A 表示这张图的邻接矩阵，矩阵第 i 行第 j列表示 i 号顶点到 j 号顶点有一条边权为 A[i][j] 的边。
接下来一行，输入 n 个数 xi，代表删除顶点的次序。
你需要求出删除了第 0 个点（一个点都没删除）到第 n−1 个点（图中还剩下一个点）时，图中所有点对的距离之和。
#include<bits/stdc++.h>
using namespace std;
const int N = 300;
int n, f[N+1][N+1],c[N+1],a[N+1];//c[]记录删点顺序
bool b[N + 1];//记录点i是否加入图中
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
scanf("%d", &f[i][j]);
for (int i = 1; i <= n; i++)scanf("%d", &c[i]);
memset(b, 0, sizeof(b));
for (int l = n; l > 0; l--) {//倒序删除顺序 即加入顺序 Floyd
int k = c[l];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
//加入k点后 更新所有距离
//i,j循环所有点，但f[i][j]只是初始值与已加入的k点更新的最小距离
//且后续会根据 b[i] b[j]判断是否该点加入 加入才会计算到ans中去
b[k] = 1;
int ans = 0;
for (int i = 1; i <= n; i++)//记录加入点c[l]时最短距离和
for (int j = 1; j <= n; j++)
if (b[i] && b[j])ans += f[i][j];
a[l] = ans;
}
for (int i = 1; i <= n; i++)printf("%d ", a[i]);
return 0;
}笔记：
1）Dijkstra与Floyd区别：
Dijkstra：一点到其他点的最短距离O(n*(nm)log n)（优化版+所有点最短路版）
vector边表存储边信息edge[x].push_back( Node( y,v ) );
Floyd：所有点之间的最短距离O(n^3)
邻接矩阵存储边信息 f [x][y]=v;
都可记录中间过程点即路径
2）数组拷贝：memcpy(f[i], dist, sizeof(dist));
3）有向图考虑将所有边反向
4）题目要求依次删点时考虑依次加点
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
