最短路，最小生成树，及拓扑排序模板整理

最新推荐文章于 2023-07-25 15:57:50 发布
最新推荐文章于 2023-07-25 15:57:50 发布
阅读量473 收藏 2
点赞数 1
分类专栏： 最短路 最小生成树 拓扑排序 |NOIPRP++| 文章标签： 最短路径算法 最小生成树 拓扑排序 NOIPRP++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36693533/article/details/78156287
版权

最短路，最小生成树，及拓扑排序都是图论基础算法，这里不再赘述，只进行模板整理，如有疑问还请评论留言
对于最短路算法，这里除常用的SPFA和堆优化Dijkstra外，还整理了许多学校和算法竞赛培训机构不会教授的Bellman_ford与原版Dijkstra，以便于读者理解前面的两种优化版本。

最短路：

最短路算法经典例题
http://codevs.cn/problem/1557/热浪 

//Bellman_ford版本
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
const int INF=100000000; 
using namespace std;
int t,c,ts,te,cnt;
int u[100000],v[100000],d[100000],w[100000];
void Bellman_ford()
{
    for(int i=1;i<=t;i++)
    d[i]=INF;
    d[ts]=0;
    for(int i=1;i<=t-1;i++)
    for(int j=1;j<=cnt;j++)
    {
        if(d[u[j]]<INF)
        d[v[j]]=min(d[v[j]],d[u[j]]+w[j]);
    }
}
int main()
{
    scanf("%d%d%d%d",&t,&c,&ts,&te);
    cnt=c;
    for(int i=1;i<=c;i++)
    {
        scanf("%d%d%d",&u[i],&v[i],&w[i]);
        u[++cnt]=v[i];
        v[cnt]=u[i];
        w[cnt]=w[i];
    }
    Bellman_ford();
    printf("%d",d[te]);
    return 0;
}



//SPFA邻接链表版本
//SPFA是Bellman_ford的队列优化
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
using namespace std;
const int INF=1000000000;
int t,c,ts,te,ru,rv,rw,tot,x;
int d[100000],first[100000],next[100000];
bool inq[100000];
queue<int>q;
struct Edge
{
    int u,v,w;
}l[100000];
void build(int u,int v,int w)
{
    l[++tot]=(Edge){u,v,w};
    next[tot]=first[u];
    first[u]=tot;
}
void SPFA()
{
    for(int i=1;i<=t;i++)
    d[i]=INF;
    d[ts]=0;
    inq[ts]=1;
    q.push(ts);
    while(!q.empty())
    {
        int k=q.front();
        q.pop();
        inq[k]=0;
        for(int i=first[k];i!=-1;i=next[i])
        {
            x=l[i].v;
            if(d[k]<INF&&d[x]>d[k]+l[i].w)
            {
                d[x]=d[k]+l[i].w;
                if(!inq[x])
                q.push(x);
                inq[x]=1;
            }
        }
    }
}
int main()
{
    memset(first,-1,sizeof(first));
    scanf("%d%d%d%d",&t,&c,&ts,&te);
    for(int i=1;i<=c;i++)
    {
        scanf("%d%d%d",&ru,&rv,&rw);
        build(ru,rv,rw);
        build(rv,ru,rw);
    }
    SPFA();
    printf("%d",d[te]);
    return 0;
}



//SPFA邻接表版本
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int INF=1000000000;
int t,c,ts,te,ru,rv,rw,tot,x,w;
int d[100000];
bool inq[100000];
vector<int>G[100000];
vector<int>V[100000];
queue<int>q;
inline void build(int u,int v,int w)
{
     G[u].push_back(v);
     V[u].push_back(w);
     G[v].push_back(u);
     V[v].push_back(w);
}
void SPFA()
{
    for(int i=1;i<=t;i++)
    d[i]=INF;
    d[ts]=0;
    inq[ts]=1;
    q.push(ts);
    while(!q.empty())
    {
        int k=q.front();
        q.pop();
        inq[k]=0;
        for(int i=0;i<G[k].size();i++)
        {
            x=G[k][i];
            w=V[k][i];
            if(d[k]<INF&&d[x]>d[k]+w)
            {
                d[x]=d[k]+w;
                if(!inq[x])
                q.push(x);
                inq[x]=1;
            }
        }
    }
}
int main()
{
    scanf("%d%d%d%d",&t,&c,&ts,&te);
    for(int i=1;i<=c;i++)
    {
        scanf("%d%d%d",&ru,&rv,&rw);
        build(ru,rv,rw);
    }
    SPFA();
    printf("%d",d[te]);
    return 0;
}



//Dijkstra版本
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const int INF=1000000000;
int t,c,ts,te,x,y,r;
int d[1000001];
int w[2500][2500]; 
bool v[1000001];
void dijkstra()
{
    for(int i=1;i<=t;i++)
    d[i]=INF;
    d[ts]=0;
    for(int i=1;i<=t;i++)
    {
        int k=0,m=INF;
        for(int j=1;j<=t;j++)
        {
            if(!v[j]&&d[j]<=m)
            {
                m=d[j];
                k=j;
            }
        }
        v[k]=1;
        for(int j=1;j<=t;j++)
        if(!v[j])
        d[j]=min(d[j],d[k]+w[k][j]);
    }
}
int main()
{
    scanf("%d%d%d%d",&t,&c,&ts,&te);
    for(int i=1;i<=t;i++)
    for(int j=1;j<=t;j++)
    {
        if(i!=j)
        w[i][j]=INF;
    }
    for(int i=1;i<=c;i++)
    {
        scanf("%d%d%d",&x,&y,&r);
        w[x][y]=w[y][x]=r;
    }
    dijkstra();
    printf("%d",d[te]);
    return 0;
}



//Dijkstra，堆优化，邻接链表版本
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN = 100000 + 5;
int t,c,ts,te,tot,rs,re,rc;
int dis[MAXN],first[MAXN],next[MAXN];
bool done[MAXN];
struct edge
{
    int f,t,v;
}l[MAXN << 1];
struct zt
{
    int num;
    int d;//距离用于排序 
    /*bool operator < (zt a)const
    {
        return d>a.d;   
    }
    friend bool operator < (zt a,zt b)
    {
        return a.d<b.d;
    }*///2种写法，仅对结构体里的小于号生效
}p[MAXN];
priority_queue<zt>q;
bool operator < (zt a,zt b)
{
    return a.d>b.d;
}
void build(int f,int t,int v)
{
    l[++tot]=(edge){f,t,v};
    next[tot]=first[f];
    first[f]=tot;
}
void dijkstra()
{
    while(!q.empty()) q.pop();
    q.push((zt){ts,0});
    dis[ts]=0;
    while(!q.empty())
    {
        zt a=q.top();
        int u=a.num;
        q.pop();
        if(done[u]==1)
        continue;
        done[u]=1;
        for(int i=first[u];i!=-1;i=next[i])
        {
            int v=l[i].t;
            if(dis[v]>dis[u]+l[i].v)
            {
                dis[v]=dis[u]+l[i].v;
                q.push((zt){v,dis[v]});
            }
        }
    }
}
int main()
{
    memset(dis,0x3f,sizeof(dis));
    memset(first,-1,sizeof(first));
    scanf("%d%d%d%d",&t,&c,&ts,&te);
    for(int i=1;i<=c;i++)
    {
        scanf("%d%d%d",&rs,&re,&rc);
        build(rs,re,rc);
        build(re,rs,rc);
    }
    dijkstra();
    printf("%d",dis[te]);
    return 0;
}



http://codevs.cn/problem/1021/玛丽卡
注意题目描述中“最糟糕的情况”指的是玛丽卡。
对答案有贡献的路径只存在于最短路上
先跑一边SPFA找出最短路上的边，依次尝试删除每条边，跑SPFA统计答案即可 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int INF = 1000000007;
int n,m,ru,rv,rw,tot,ans;
int dis[500010],first[1000010],nxt[1000010],pre[500010];
bool flag;
bool inq[100010];
struct edge
{
    int u,v,w;
}l[1000010];
queue<int>q;
void build(int f,int t,int c)
{
    l[++tot]=(edge){f,t,c};
    nxt[tot]=first[f];
    first[f]=tot;
}
void SPFA(int l1,int l2)
{
    for(int i=1;i<=n;i++)
    dis[i]=INF;
    dis[1]=0;
    q.push(1);
    inq[1]=1;
    while(!q.empty())
    {
        int k=q.front();
        q.pop();
        inq[k]=0;
        for(int i=first[k];i!=-1;i=nxt[i])
        {
            int x=l[i].v;
            if((k==l1&&x==l2)||(k==l2&&x==l1))
            continue;
            if(dis[x]>dis[k]+l[i].w)
            {
                dis[x]=dis[k]+l[i].w;
                if(!flag)
                pre[x]=k;//记录最短路径上的边
                if(!inq[x])//若每次更新都记录起点及起点出发的边的编号会导致记录部分不在最短路径上的边...虽然不影响答案
                {
                    q.push(x);
                    inq[x]=1;
                }
            }
        }
    }
}
int main()
{
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&ru,&rv,&rw);
        build(ru,rv,rw);
        build(rv,ru,rw);
    }
    tot=0;
    SPFA(0,0);
    flag=1;
    for(int i=n;i;i=pre[i])
    {
        SPFA(i,pre[i]);
        ans=max(ans,dis[n]);
    }
    printf("%d",ans);
    return 0;
}


最小生成树：

http://codevs.cn/problem/1231/最优布线问题 

//Kruskal版本
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
typedef unsigned long long LL;
int n,m,cnt,x,y,e;
int u[1000000],v[1000000],w[1000000],r[1000000],fa[1000000];
LL cost;
bool cmp(int a,int b)
{
    return w[a]<w[b];
}
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
void kruskal()
{
    for(int i=1;i<=n;i++)
    fa[i]=i;
    for(int i=1;i<=m;i++)
    r[i]=i;
    sort(r+1,r+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        e=r[i];
        x=find(u[e]);
        y=find(v[e]);
        if(x!=y)
        {
            cost+=w[e];
            fa[x]=y;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    cnt=n;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u[i],&v[i],&w[i]);
    }
    kruskal();
    printf("%lld",cost);
    return 0;
}



//Prim
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
using namespace std;
typedef unsigned long long LL;
const int MAXN=1000000;
LL n,m,rf,rt,rv,tot,cost,cnt;
LL first[MAXN],next[MAXN];
bool done[MAXN];
struct Edge
{
    LL f,t,v;
}l[MAXN];
struct condition 
{
    LL num,d;
}p[MAXN];
priority_queue<condition>q;
bool operator < (condition a,condition b)
{
    return a.d>b.d;
}
void build(int f,int t,int v)
{
    l[++tot]=(Edge){f,t,v};
    next[tot]=first[f];
    first[f]=tot;
}
void prim()
{
    while(!q.empty()) q.pop();
    q.push((condition){1,0});
    while(!q.empty()&&cnt<n)
    {
        condition a=q.top();
        LL u=a.num;
        LL w=a.d;
        q.pop();
        if(done[u])
        continue;
        done[u]=1;
        cost+=w;
        cnt++;
        for(int i=first[u];i!=-1;i=next[i])
        if(!done[l[i].t])
        q.push((condition){l[i].t,l[i].v});
    }
}
int main()
{
    memset(first,-1,sizeof(first));
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%lld%lld%lld",&rf,&rt,&rv);
        build(rf,rt,rv);
        build(rt,rf,rv);
    }
    prim();
    printf("%lld",cost);
    return 0;
}


拓扑排序：

http://codevs.cn/problem/2833/奇怪的梦境 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
queue<int>q;
int n,m,ru,rv,tot,cnt,fla;
int first[100001],next[100001],pas[100001],ans[100001],jud1[100001],jud2[100001];
bool flag;
struct spot
{
    int u,v;
}l[100001];
void build(int f,int t)
{
    l[++tot]=(spot){f,t};
    next[tot]=first[f];
    first[f]=tot;
}
int main()
{
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&ru,&rv);
        if(jud1[ru]==rv)
        continue;
        pas[rv]++;
        jud1[ru]=rv;
        build(ru,rv);
    }
    for(int i=1;i<=n;i++)
    if(pas[i]==0)
    q.push(i);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        ans[++cnt]=x;
        for(int i=first[x];i!=-1;i=next[i])
        {
            pas[l[i].v]--;
            if(pas[l[i].v]==0)
            q.push(l[i].v);
        }
    }
    if(cnt>=n)
    printf("o(∩_∩)o");
    else
    {
        printf("T_T\n");
        printf("%d",n-cnt);
    }
    return 0;
}
MaywrILoi
关注
专栏目录
拓扑排序的经典模板
08-18
你还在手打拓扑排序吗？那你赶紧下载这款源代码。它可以减轻你手的负担。
拓扑排序详解（超详细+模板）
wait
08-09 1万+
拓扑排序 1.什么是拓扑排序 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图 中任 意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序 (Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个...
浅谈拓扑排序（模板+例题）
wcqqq的博客
04-15 2888
所谓拓扑排序就是对一个有向无环图G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。 可能这个定义有点难理解，那接下来我就说说它的具体流程。（真的容易理解的） 进入正题 随便的给你一个有向无环图 1：找到入度为0的点 就像此图，它入度为0的点是1和4，将它们取出来，记为第一个数和第二个数。并且把与它们有关的边都去掉（这个图就没有哈） 2:重复上述操作。 取出入度为0的点，现在入度为0的点是2，
拓扑排序 （算法思想+图解+模板+练习题）
热门推荐
暴躁小吕的博客
01-13 3万+
如果是一个有向无环图，那么一定有一个点的入度为0，如果找不到一个入度为0的点，这个图一定是带环的。将队列里的点依次出队列，然后找出所有出队列这个点发出的边，删除边，同时边的另一侧的点的入度 -1。对于有向图每个结点都有入度和出度，入度就是指向该结点的边数，出度就是该结点指向其他结点的边数。一个有向图，如果图中有入度为 0 的点，就把这个点删掉，同时也删掉这个点所连的边。然后D的入度为0，我们同样操作，最后图被删除干净，证明可以拓扑排序。总结一下拓扑排序就是只有从前指向后的边，没有从后指向前的边。
图论模板（拓扑排序、最短路）
心升明月的博客
09-10 720
图论模板一、拓扑排序题意代码二、Dijkstra题意代码1（朴素版）代码2（堆优化版）2.读入数据总结 一、拓扑排序 题意 输出拓扑排序，如果不存在输出-1. 代码 void topsort() { queue<int> que; for(int i=1;i<=n;i++) if(!din[i]) que.push(i), ans[++num] = i; while(que.size()){ int t = que.fron
ACM图论数据结构常见模板
09-26
最小生成树 18 最小树形图 20 拓扑排序 22 最大团 23 LCA 24 倍增 24 基于RMQ（ST表） 26 Tarjan 28 二分图 31 相关总结 31 二分图最大匹配 32 二分图最大权匹配 35 网络流 38 最大流 && 最小割 38 费用流 46 一般...
kuangbin acm模板超级好用
09-05
1 字符串处理 5 1.1 KMP . . . . ....3.3 树链剖分 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 3.3.1 点权 . . . . . . . . . . . . . . . . . . . . . . ...
ACM修炼之路模板
10-02
最小生成树 - **Prim算法**: 时间复杂度\( O(V^2) \)。 - **Kruskal算法**: 时间复杂度\( O(E \log E) \)。 ##### 2. 最小树形图 (朱刘算法) - **定义**: 在有根树中找到包含所有节点的最小树形图。 - **应用场景*...
ACM图论模板_BY夏天的风
08-10
最小生成树：在加权无向图中，连接所有顶点并且边的权值之和最小的树。模板中提到了Kruskal和Prim两种常见的求解方法。 LCA与RMQ（最近公共祖先和区间查询）：LCA用于求解树上任意两点的最近公共祖先，而RMQ是解决...
拓扑排序模板
qq_43070117的博客
11-22 357
拓扑排序模板： vector<int> g[N]; queue<int> q; int deg[N];//出度数 for (int i = 1; i <= n; i++) if (deg[i] == 0) q.push(i);//初始化,将叶子节点加入队列 int cnt = 0; while (!q.empty()) { int t = q.front(); q.pop(
算法基础学习笔记——⑪拓扑排序\最短路
VLOKL的博客
05-27 1482
算法基础学习笔记——⑪拓扑排序\最短路
拓扑排序模板（附带题解：有向图的拓扑序列+Fine Logic）
最新发布
weixin_60536621的博客
07-25 451
拓扑排序模板（附带题解：有向图的拓扑序列+Fine Logic）
数据结构与算法之美笔记(十一)拓扑排序和最短路径
qq_51955445的博客
02-10 1203
拓扑排序： 解决的问题：有多个事件，事件之间存在依赖关系，我们要确定一个处理事件的顺序，并保证在完成当前事件之前，他所依赖的事件必须已经被执行了、 算法是构建在具体的数据结构之上的。针对这个问题，我们先来看下，如何将问题背景抽象成具体的数据结构？ 我们可以把事件之间的依赖关系，抽象成一个有向图。每个事件对应图中的一个顶点，事件之间的依赖关系就是顶点之间的边。 如果a先于b执行，也就是说b依赖于a，那么就在顶点a和顶点b之间，构建一条从a指向b的边。而且，这个图不仅要是有向图，还要是一个有向无环图，也就是不能
拓扑排序代码模板C++
weixin_43595277的博客
08-14 2066
算法步骤: ①定义一个队列Q，并把所有入度为0的结点加入队列。 ②取队首结点，输出。然后删去所有从它出发的边，并令这些边到达的顶点的入度减1，如果某个顶点的入度减为0，则将其加入队列。 ③反复进行②操作，直到队列为空。如果队列为空时入过队的结点数目恰好为N，说明拓扑排序成功，图G为有向无环图;否则，拓扑排序失败，图G中有环。 可使用邻接表实现拓扑排序。显然，由于需要记录结点的入度，因此需要额外建立一个数组inDegree[MAXV]，并在程序一开始读入图时就记录好每个结点的入度。接下来就只需要按上面所说.
图论——拓扑排序及最短路径算法模板
qq56106的博客
03-30 692
拓扑排序、多源最短路、单源最短路
学习笔记：拓扑排序c++两种模板
weixin_58428691的博客
09-21 673
各人学习笔记
【LeetCode】拓扑排序
flora
06-18 1107
拓扑排序拓扑排序 模板AcWing 848. 有向图的拓扑序列 拓扑排序 模板 拓扑排序 用bfs来访问所有的节点，把入度为0的节点加入到队列中；每次从队列中取出一个节点，相当于从图删除这个节点，这样此节点的后继节点的入度都减1，再把入度为0的节点加到队列中。 时间复杂度 时间复杂度 O(n+m)O(n+m), nn 表示点数，mm 表示边数 java 模板 AcWing 848. 有向图的拓扑序列 【题目描述】 给定一个n个点m条边的有向图，点的编号是1到n，图中可能存在重边和自环。 请输出任意一个该
图论算法模板集：强联通、最短路、最小生成树与网络流解析
内容涵盖了强联通、最短路、最小生成树、欧拉路径、二分图、2-SAT、最近公共祖先（LCA）、最大团、差分约束系统、拓扑排序以及网络流等多个重要概念。每个主题下都有相应的算法介绍和代码示例，部分代码还带有注释，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值