【算法模板】图论：拓扑序+最短路+最小环

最新推荐文章于 2024-06-13 10:13:20 发布

T0uken

最新推荐文章于 2024-06-13 10:13:20 发布

阅读量1.1k

点赞数 30

文章标签：算法图论

本文链接：https://blog.csdn.net/2303_80346267/article/details/139092634

版权

拓扑排序

概念

拓扑排序是指对有向无环图（DAG）进行排序的一种算法。在拓扑排序中，图中的顶点被排成一个线性序列，使得如果图中有一条从顶点A到顶点B的有向边，那么在排序中顶点A一定在顶点B的前面。换句话说，拓扑排序将图中的顶点按照依赖关系进行排序，确保所有的依赖关系都被满足。

模板

vector<int> toposort(const vector<vector<int>>& e) {//Kahn（卡恩）算法
    const int n = e.size();
    vector<int> din(n), tp;//din存点的入度，tp存拓扑序列
    queue<int> q;//入度为0的点的集合
    for (const auto& v : e)for (const int& i : v)din[i]++;
    for (int i = 0; i < n; i++)if (din[i] == 0) q.push(i);
    while (q.size()) {
        int x = q.front(); q.pop();
        tp.push_back(x);
        for (const int& y : e[x])if (--din[y] == 0) q.push(y);
    }
    return tp;
}

例题

Ordering Tasks - UVA 10305 - Virtual Judge (vjudge.net)

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
vector<int> toposort(const vector<vector<int>>& e) {//Kahn（卡恩）算法
    const int n = e.size();
    vector<int> din(n), tp;//din存点的入度，tp存拓扑序列
    queue<int> q;//入度为0的点的集合
    for (const auto& v : e)for (const int& i : v)din[i]++;
    for (int i = 0; i < n; i++)if (din[i] == 0) q.push(i);
    while (q.size()) {
        int x = q.front(); q.pop();
        tp.push_back(x);
        for (const int& y : e[x])if (--din[y] == 0) q.push(y);
    }
    return tp;
}
int main() {
    int n, m; cin >> n >> m;
    vector<vector<int>> edges(n);
    while (m--) {
        int a, b; cin >> a >> b;
        --a, --b;
        edges[a].push_back(b);
    }
    cin >> m >> m;
    auto tp = toposort(edges);
    for (int i : tp)cout << ++i << ' ';
}

弗洛伊德

概念

Floyd 是基于动态规划的多源最短路的算法。

定义f[k][i][j]为经过前k个书点，从i到j的最短路径:

f[k][i][j]可以从f[k-1][i][j]转移过来，即不经过第K个节点。
也可以从f[k-1][i][k]+f[k-1][k][j]转移过来，即经过第k个节点。

综上，转移方程为f[k][i][j]=min(f[k-1][i][j],f[k-1][i][k]+f[k-1][k][j])。

我们观察一下上述状态转移方程，在更新f[k]层状态的时候，只用到了f[k-1]层的值，f[k-2]及之前的层的值都用不上了。

模板

pair<vector<vector<long long>>, vector<vector<int>>> floyd(const vector<vector<long long>>& e) {
    int n = e.size();
    auto dis(e);
    vector<vector<int>> pre(n, vector<int>(n,-1));
    for (int k = 0 ; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (dis[i][j] > dis[i][k] + dis[k][j]) {
                    dis[i][j] = dis[i][k] + dis[k][j];
                    pre[i][j] = k;
                }
    return { dis, pre };

迪杰斯特拉

单源最短路径问题(Single Source Shortest Path,SSSP问题)是说，给定一张有向图G=(V,E),V是点集，E是边集，|V|=n,|E|=m,节点以[1,n]之间的连续整数编号， (x,y,z)描述一条从x出发，到达y，长度为z的有向边。设1号点为起点，求长度为n的数组 dist,其中dist[i]表示从起点1到节点i的最短路径的长度。

概念

初始化dist[起点]=0,其余节点的dist值为正无穷大。
找出一个未被标记的、dist[x]最小的节点x，然后标记节点x。
扫描节点x的所有出边(x,y,z),若dist[y]>dist[x]+z,则使用dist[x]+ z更新dist[y]。
重复上述2~3两个步骤，直到所有节点都被标记。

Dijkstra算法基于贪心思想，它只适用于所有边的长度都是非负数的图。当边长2 都是非负数时，全局最小值不可能再被其他节点更新，故在第1步中选出的节点x必然满足:dist[x]已经是起点到x的最短路径。我们不断选择全局最小值进行标记和扩展，最终可得到起点1到每个节点的最短路径的长度。

模板

const long long INF = 0x3f3f3f3f3f3f3f3fLL;//INF <= INF+x
struct edge { int to; long long len; };
pair<vector<long long>, vector<int>> dijkstra(const vector<vector<edge>> &e,int s) 
{//注意有向图无向图，节点序号从0开始
    int n = e.size();
    vector<bool> done(n);//标记访问
    vector<int> pre(n,-1);//前驱路径
    vector<long long>dis(n, INF);//到起点距离
    dis[s] = 0;
    priority_queue <pair<long long,int>> Q;//小根堆，距离存负
    Q.push({ s, dis[s] });
    while (!Q.empty()) {
        int u = Q.top().second;
        Q.pop();
        if (done[u])  continue;//丢弃已经找到最短路径的结点。即集合A中的结点
        done[u] = true;
        for (edge y: e[u]) {//检查结点u的所有邻居
            if (done[y.to])  continue;//丢弃已经找到最短路径的邻居结点
            if (dis[y.to] > y.len + dis[u]) {
                dis[y.to] = y.len + dis[u];
                Q.push({ -dis[y.to],y.to  });//扩展新的邻居，放到优先队列中
                pre[y.to] = u;//如果有需要，记录路径
            }
        }
    }
    return { dis, pre };
}

例题

蓝桥王国 - 蓝桥云课 (lanqiao.cn)

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
#define int long long
const int INF = 0x3f3f3f3f3f3f3f3fLL;;
struct side { int to, len; };
vector<int> Dij(const vector<vector<side>>& edges,int start) {
    const int n = edges.size();
    vector<int> dis(n,INF); 
    dis[start] = 0;
    priority_queue<pair<int,int>> q;
    q.push({ -dis[start],start });
    vector<bool> vis(n);
    while (!q.empty()) {
        int nowp = q.top().second;
        q.pop();
        if (vis[nowp])continue;
        vis[nowp] = true;
        for (side s : edges[nowp]) {
            if (vis[s.to])continue;
            if (dis[nowp] + s.len < dis[s.to]) {
                dis[s.to] = dis[nowp] + s.len;
                q.push({ -dis[s.to],s.to });
            }
        }
    }
    return dis;
}
signed main() {
    int n, m; cin >> n >> m;
    vector<vector<side>> edges(n);
    while (m--) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        edges[u].push_back({v,w});
    }
    auto dis = Dij(edges, 0);
    for (int i : dis)cout << (i < INF ? i : -1) << ' ';
    return 0;
}

SPFA

概念

我们先介绍基于迭代思想的Belliman-Ford算法。它的流程如下。

扫描所有边(x,y,z),若dist[y]>dist[x]+z,则用dist[x]+z更新dist[y].
重复上述步骤，直到没有更新操作发生。 Bellman-Ford 算法的时间复杂度为0(nm)。

实际上，SPFA算法在国际上通称为“队列优化的Bellman-Ford算法”，仅在中国大陆流行"SPFA算法”的称谓。 SPFA算法的流程如下。

建立一个队列，最初队列中只含有起点1.
取出队头节点x，扫描它的所有出边(x,y,z),若dist[y]> dist[x]+z,则使用dist[x]+z更新dist[y].同时，若y不在队列中，则把y入队。
重复上述步骤，直到队列为空。

在任意时刻，该算法的队列都保存了待扩展的节点。每次入队相当于完成一次dist 数组的更新操作，使其满足三角形不等式。一个节点可能会入队、出队多次。最终，图中节点收敛到全部满足三角形不等式的状态。这个队列避免了Bellman-Ford算法中对不需要扩展的节点的冗余扫描，在随机图上运行效率为0(km)级别，其中k是一个较小的常数。但在特殊构造的图上，该算法很可能退化为0(nm),必须谨慎使用。

模板

pair<vector<long long>, vector<int>> spfa(const vector<vector<edge>>& e, int s) {
    int n = e.size();
    vector<int> pre(n, -1);//前驱路径
    vector<long long>dis(n, INF);//到起点距离
    vector<int> cnt(n);
    vector<bool> inq(n);//标记u点是否在队内
    queue<int> q;//本轮被更新的出边才有可能下一轮松弛，记录被更新点
    dis[s] = 0; inq[s] = true; q.push(s);
    while (q.size()) {
        int u = q.front(); q.pop();
        inq[u] = false;
        for (edge ed : e[u]) if (dis[ed.to] > ed.len + dis[u]) {
            dis[ed.to] = ed.len + dis[u];
            cnt[ed.to] = cnt[u] + 1;
            pre[ed.to] = u;//如果有需要，记录路径
            if (cnt[ed.to] >= n) {
                dis.clear(); pre.clear();
                return { dis,pre };
            }
            if (!inq[ed.to])q.push(ed.to), inq[ed.to] = true;
        }
    }
    return { dis,pre };
}

例题

蓝桥王国 - 蓝桥云课 (lanqiao.cn)

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
#define int long long
const int INF = 0x3f3f3f3f3f3f3f3fLL;;
struct side { int to, len; };
vector<int> spfa(vector<vector<side>> edges, int start) {
    const int n = edges.size();
    vector<int> dis(n,INF);
    dis[start] = 0;
    queue<int> q;
    q.push(start);
    vector<bool> inque(n);
    inque[start] = true;
    while (!q.empty()) {
        int nowp = q.front();
        q.pop();
        inque[nowp] = false;
        for (side s : edges[nowp]) {
            if (dis[s.to] > dis[nowp] + s.len) {
                dis[s.to] = dis[nowp] + s.len;
                if (!inque[s.to])q.push(s.to);
            }
        }
    }
    return dis;
}
signed main() {
    int n, m; cin >> n >> m;
    vector<vector<side>> edges(n);
    while (m--) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        edges[u].push_back({v,w});
    }
    auto dis = spfa(edges, 0);
    for (int i : dis)cout << (i < INF ? i : -1) << ' ';
    return 0;
}

最小环

概念

在图论中，最小环指的是一个图中的一个环（即一条路径，起点和终点相同），其权重（或长度）是所有环中最小的。换句话说，最小环是在图中形成一个环，且该环的权重是所有环中最小的。找到图中的最小环可以帮助解决一些优化问题，如旅行商问题等。

记原图𝑢,𝑣之间边权为𝑚𝑝(𝑢,𝑣),floyd算法在外层循环到第k个点时(还没开始第k次循环),最短路数组𝑔中，𝑔(𝑢,𝑣)表示的是从𝑢到𝑣且仅经过编号[1,𝑘)区间中的点的最短路。最小环至少有三个顶点，设其中编号最大的顶点编号为𝑤，环上与𝑤相邻两侧的两个点为𝑢,𝑣,则在最外层循环枚举到𝑘=𝑤时，该环的长度为𝑔(𝑢,𝑣)+𝑚𝑝(𝑣,𝑤)+𝑚𝑝(𝑤,𝑢)，所以在循环时候𝑖,𝑗只需枚举到𝑖<𝑘,𝑗<𝑘，更新答案即可

模板题

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int INF = 1e8;
signed main() {
    int n, m; cin >> n >> m;
    vector<vector<int>> w(n, vector<int>(n,INF));
    for (int i = 0; i < n; i++)w[i][i] = 0;
    while (m--) {
        int u, v, d;
        cin >> u >> v >> d;
        --u, --v;
        w[u][v] = w[v][u] = min(d,w[u][v]);
    }
    auto dis = w;
    int ans = INF;
    for (int k = 0; k < n; k++) {
        for (int i = 0; i <= k-2; i++)
            for (int j = i + 1; j <= k-1; j++)
                ans = min(ans, dis[i][j] + w[j][k] + w[k][i]);
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
    }
    if (ans < INF)cout << ans << endl;
    else cout<<"No solution."<<endl;
    return 0;
}

T0uken

关注

30
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
【算法模板】图论：拓扑序+最短路+最小环

单源最短路径问题(Single Source Shortest Path,SSSP问题)是说，给定一张有向图G=(V,E),V是点集，E是边集，|V|=n,|E|=m,节点以[1,n]之间的连续整数编号， (x,y,z)描述一条从x出发，到达y，长度为z的有向边。综上，转移方程为f[k][i][j]=min(f[k-1][i][j],f[k-1][i][k]+f[k-1][k][j])。扫描节点x的所有出边(x,y,z),若dist[y]>dist[x]+z,则使用dist[x]+ z更新dist[y]。
复制链接

扫一扫