最短路（基础板子）

最新推荐文章于 2024-11-16 21:36:47 发布
最新推荐文章于 2024-11-16 21:36:47 发布
阅读量140 收藏
点赞数
分类专栏： 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50935546/article/details/118691870
版权

c语言 算法

内容

1.朴素版Dijkstra

题目:A - Til the Cows Come Home

#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int mp[1010][1010],dist[1010],vis[1010];
void Dij()
{
    for(int i=1;i<=n;i++)dist[i]=mp[n][i];
    vis[n]=1;
    for(int i=1;i<=n;i++)
    {
        int f=-1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&(f==-1||dist[f]>dist[j]))f=j;
        }
        vis[f]=1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j])dist[j]=min(dist[j],dist[f]+mp[f][j]);
        }
    }
    printf("%d\n",dist[1]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j)mp[i][j]=0;
                else mp[i][j]=INF;
            }
        }
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(mp[x][y]>z)mp[x][y]=mp[y][x]=z;
        }
        memset(vis,0,sizeof(vis));
        Dij();
    }
    return 0;
}

2.堆优化Dijkstra

题目：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围
1≤n,m≤1.5×105,
图中涉及边长均不小于 0，且不超过 10000。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

const int N=150010;
int n,m;
int h[N],w[N],e[N],ne[N],idx;
typedef pair<int,int>PII;
int dist[N],vis[N];
void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}
void Dij()
{
    priority_queue<PII,vector<PII>,greater<PII> >heap;
    dist[1]=0;
    heap.push({0,1});
    while(!heap.empty())
    {
        PII t=heap.top();heap.pop();
        int ver=t.second,dis=t.first;
        if(vis[ver])continue;
        vis[ver]=1;
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dis+w[i])
            {
                dist[j]=dis+w[i];
                heap.push({dist[j],j});
            }
        }
    }
    if(dist[n]==INF)printf("-1\n");
    else printf("%d\n",dist[n]);
}
int main()
{
    memset(h,-1,sizeof(h));
    memset(vis,0,sizeof(vis));
    memset(dist,INF,sizeof(dist));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    Dij();
    return 0;
}

3.Bellman-Ford算法

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式
第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过 10000。

输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3

int n,m,k;
struct edges
{
    int a,b,w;
}edge[10010];
int dist[510],backup[510];
void bellman()
{
    memset(dist,INF,sizeof(dist));
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(backup,dist,sizeof(dist));
        for(int j=1;j<=m;j++)
        {
            int a=edge[j].a,b=edge[j].b,w=edge[j].w;
            dist[b]=min(dist[b],w+backup[a]);
        }
    }
    if(dist[n]>INF/2)printf("impossible\n");
    else printf("%d\n",dist[n]);
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].w);
    }
    bellman();
    return 0;
}

4.SPFA算法

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围
1≤n,m≤105,
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

const int N=100010;
int h[N],w[N],e[N],ne[N],idx;
int dist[N],vis[N];
int n,m;
void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}
void SPFA()
{
    memset(dist,INF,sizeof(dist));
    memset(vis,0,sizeof(vis));
    queue<int>q;
    dist[1]=0;
    q.push(1);
    vis[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=0;
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>w[i]+dist[t])
            {
                dist[j]=w[i]+dist[t];
                if(!vis[j])
                {
                    q.push(j);
                    vis[j]=1;
                }
            }
        }
    }
    if(dist[n]==INF)printf("impossible\n");
    else printf("%d\n",dist[n]);
}
int main()
{
    memset(h,-1,sizeof(h));
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    SPFA();
    return 0;
}

5.Floyd算法

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。
Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。
Output
对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.
Sample Input
3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2
Sample Output
2
-1

int mp[210][210];
int n,m;
int s,t;
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(i==j)mp[i][j]=0;
                else mp[i][j]=INF;
            }
        }
        for(int i=1;i<=m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(mp[a][b]>c)mp[a][b]=mp[b][a]=c;
        }
        scanf("%d%d",&s,&t);
        for(int k=0;k<n;k++)
        {
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(mp[i][j]>mp[i][k]+mp[k][j])mp[i][j]=mp[i][k]+mp[k][j];
                }
            }
        }
        if(mp[s][t]==INF)printf("-1\n");
        else printf("%d\n",mp[s][t]);
    }
    return 0;
}

6.bellmon判断是否存在正环

题目:E - Currency Exchange

int n,m,s;
double v;
struct cur
{
    int a,b;
    double r,c;
}cc[210];
double dist[110];
void bellmon()
{
    memset(dist,0,sizeof(dist));
    dist[s]=v;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=2*m;j++)
        {
            if((dist[cc[j].a]-cc[j].c)*cc[j].r>dist[cc[j].b])
                dist[cc[j].b]=(dist[cc[j].a]-cc[j].c)*cc[j].r;
        }
    }
    int flag=0;
    for(int j=1;j<=2*m;j++)
    {
        if((dist[cc[j].a]-cc[j].c)*cc[j].r>dist[cc[j].b])
        {
            flag=1;
            break;
        }
    }
    if(flag==1)printf("YES\n");
    else printf("NO\n");
}
int main()
{
    while(~scanf("%d%d%d%lf",&n,&m,&s,&v))
    {
        for(int i=1;i<=m;i++)
        {
            int a,b;
            double rab,cab,rba,cba;
            scanf("%d%d%lf%lf%lf%lf",&a,&b,&rab,&cab,&rba,&cba);
            cc[i].a=a;cc[i].b=b;cc[i].r=rab;cc[i].c=cab;
            cc[i+m].a=b;cc[i+m].b=a;cc[i+m].r=rba;cc[i+m].c=cba;
        }
        bellmon();
    }
    return 0;
}

7…bellmon判断是否存在负环

F - Wormholes

int t,n,m,w;
struct path
{
    int a,b,c;
}pp[5500];
int dist[510];
void bellmon()
{
    memset(dist,INF,sizeof(dist));
    dist[1]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m*2+w;j++)
        {
            if(dist[pp[j].b]>dist[pp[j].a]+pp[j].c&&dist[pp[j].a]!=INF)
                dist[pp[j].b]=dist[pp[j].a]+pp[j].c;
        }
    }
    int flag=0;
    for(int j=1;j<=m*2+w;j++)
    {
        if(dist[pp[j].b]>dist[pp[j].a]+pp[j].c)
        {
            flag=1;
            break;
        }
    }
    if(flag==1)printf("YES\n");
    else printf("NO\n");
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&w);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&pp[i].a,&pp[i].b,&pp[i].c);
            pp[i+m].a=pp[i].b;pp[i+m].b=pp[i].a;pp[i+m].c=pp[i].c;
        }
        for(int i=m*2+1;i<=m*2+w;i++)
        {
            scanf("%d%d%d",&pp[i].a,&pp[i].b,&pp[i].c);
            pp[i].c=-pp[i].c;
        }
        bellmon();
    }
    return 0;
}
FAUX123455
关注
专栏目录
最短路板子
lppppppppps的博客
07-20 175
1 ACW849 初学图论，月底前学完图论课，这个专题是很重要、基础的最短路，这两天让HDU搞自闭了，后续更些基础题。 先是朴素dij，不妨先将点分为两部分：S集合（包含已确定最短路的点）和T集合（包含还未确定最短路的点）。主要思路是n个点，每个点只扩展1次求得所有点的最短路，以下方法可以保证每个点只扩展一次（因为每个点拓展一次后就确定了，将它加入S，再也用不到它扩展了）：每次从T集合中的所有点中选出一个距离当前源点距离dist最短的点，该点一定是所有点中的源点到其距离dist最短的点（在图中很好理解，边无
最短路板子第一弹·Dijkstra基础
Xylodesu
10-19 342
1. Dijkstra 无图警告 1.1 思路   Dijkstra的来历不必多讲，但是需要知道的，是Dijkstra是一种基于“贪心“的求“单源最短路”算法，和最小生成树中的Prim是类似的。（如果你不知道什么是单源最短路，建议百度一下再来）   粗略来讲，Dijkstra的做法就是： 以起始点为中心向外层层扩展，直到扩展到终点为止 ——百度百科   既然是这样，我...
最短路算法（Floyd算法，Dijkstra算法，Bellman-Ford算法，SPFA算法）
baodream的博客
01-31 790
1.Floyd算法 //1.Floyd算法,多源无负权 //通过邻接矩阵跑出所有点之间的最短路,时间复杂度O(n^3),空间复杂度O(n^2) //d[i][j]表示i到j的最短路径长度,初始化：d[i][i]=0,点到点有路按正常权值初始化,其余INF int mp[n][n]; int d[n][n]; void Floyd() { for(int i=1;i<=n;i++)
最短路的一些板子
the CodeRoom of wjfwzzc
04-03 1547
起因是一场训练赛，这道题我和Thor拿出了正解（之一），但非常令人发指地送出了不计其数的TLE。 　　题干不说了，我们的做法是前向星建图，然后每个LPG（起点终点也算LPG）跑一遍SPFA，然后所有LPG重新前向星建图，再跑一遍SPFA。复杂度大概是O(k1*n+k2*m^2)，按理说不会超时啊…… 　　然后我们发现昂神的做法前面和我们一样，后面建邻接矩阵，跑一遍Floyd，理论复杂度是O(k
【最短路】【k短路】Remmarguts' Date
qq_43398760的博客
06-04 359
poj2449 Description 给定一张N个点，M条边的有向图，求从起点S到终点T的第K短路的长度，路径允许重复经过点或边。其中 1≤S,T≤ N≤1000,0≤M≤〖10〗^5,1≤K≤1000。注：不熟悉最短路的读者可以简单浏览0x61节，或者假设我们能够在一张 图上求出单源最短路（从一个点出发到其他所有点的最短路径长度），然后在此基础上考虑本题。 Description "G...
虫洞路线（最短路）
yhhy666的博客
07-04 400
N个虫洞，M条单向跃迁路径。从一个虫洞沿跃迁路径到另一个虫洞需要消耗一定量的燃料和1单位时间。虫洞有白洞和黑洞之分。设一条跃迁路径两端的虫洞质量差为delta。 1.从白洞跃迁到黑洞，消耗的燃料值减少delta，若该条路径消耗的燃料值变为负数的话，取为0。 2.从黑洞跃迁到白洞，消耗的燃料值增加delta。 3.路径两端均为黑洞或白洞，消耗的燃料值不变化。 作为压轴题，自然不会是如此简单的最短路问题，所以每过1单位时间黑洞变为白洞，白洞变为黑洞。在飞行过程中，可以选择在一个虫洞停留1个单位.
【大作业】城市地铁线路最短路规划及路径输出（满分）
繁凡さん的博客
07-15 5806
城市地铁线路规划完整大作业（思路分析+构造数据+代码+优化+算法分析）
基础算法板子（更新中）
cloudy_happy的博客
08-06 898
ps：最近比较忙，以后会把以前落的补了 拓扑排序（时间复杂度N^3）： const int maxn = (int)5e2 + 10; int G[maxn][maxn]; int vis[maxn]; int n,m; void toposort() { for (int i = 1;i <= n;i ++) { for (int j = 1;j <= n;j ++) ...
最短路的Floyd-Dijkstra-Spfa板子
02-06
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
最短路板子及其应用
Doctor_Anonymous的博客
06-01 376
​ 我们注意到，每次找到不在集合中的点的时间复杂度最高。故我们才用小根堆，其可以有效解决这个问题。
各种最短路的板子
博客迁移http://www.cnblogs.com/xzz_233/
11-14 542
发个最短路板子。。
最短路入门板子及各自题目
AsUs.的博客
09-14 502
目录单源最短路朴素Dijkstra求最短路（O(n^2)）堆优化版Dijkstra求最短路（O(mlogn)）有边数限制的最短路（Bellman_Ford）（O(nm)）spfa求最短路（一般O(m)，最坏（O(nm)））spfa判断负环多源汇最短路Floyd求最短路（O(n^3)）练习题（持续更新） 单源最短路 朴素Dijkstra求最短路（O(n^2)） 题目链接 给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。 请你求出 1 号点到 n 号点的最短距离，如果无法从 1
C/C++内存管理
2301_76564849的博客
11-12 1190
(1)如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申。它的作用域仅限于定义它的文件，和全局变量类似，在程序运行开始就分配内存，到程序结束才释放内存，只不过访问范围更受限。注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[ ]和delete[ ]。2.在申请的空间上执行构造函数，完成对象的构造。
动态内存管理（c语言）
2402_86350741的博客
11-15 1260
限于水平，本篇文章不足之处在所难免，还望读者见谅，如有问题，请大家指正下。
int溢出值(c基础)
lb3636363636的博客
11-13 390
1. **整数类型** - **字节型（byte）** - **定义**：字节型通常占用1个字节（8位）存储空间。 - **范围**：在有符号的情况下，范围是从 - 128到127（使用补码表示，最小值为$10000000$，最大值为$01111111$）；在无符号的情况下，范围是从0到255（所有8位都是数值位，最小值为$00000000$，最大值为$11111111$）。 - **短整型（short）** - **定义**：一般占用2个字节（16位）存储空间。 - **范围**：有符号时，范围是 - 3
算法：快排(三指针算法)
最新发布
qincjun的博客
11-16 390
快排：三指针算法
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
zhaoylzy的博客
11-16 1025
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值