最短路

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量85 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhe_zhenbuhui_a/article/details/107922010
版权

最短路算法

POJ 1797 题目链接

题意

n个点，m条带权边，求点1到点n的所有路径中最小边的最大值。

思路

利用迪杰斯特拉的遍历过程找到路径的最小值

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1111;
const int INF = 0x3f3f3f3f;
int lowcost[N],vis[N],g[N][N];
void dijkstra(int n)
{
    memset(lowcost,0x3f,sizeof(lowcost));
    memset(vis,0,sizeof(vis));
    for (int i = 1; i <= n; i++){
        lowcost[i] = g[1][i];
    }
    vis[1] = 1;
    for (int i = 1; i < n; i++){
        int  pos = 1,mi = -2e9;
        for (int j = 2; j <= n; j++){
            if (!vis[j] && lowcost[j] > mi){
                mi = lowcost[j];
                pos = j;
            }
        }
        vis[pos] = 1;
        for (int j = 1; j <= n; j++){
            if (vis[j]) continue;
            if (lowcost[j] < min(lowcost[pos],g[pos][j])){
                lowcost[j] = min(lowcost[pos],g[pos][j]);
            }
        }
    }
    printf("%d\n\n",lowcost[n]);
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d %d",&n,&m);
        memset(g,-1,sizeof(g));
        for (int i = 0; i < m; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            g[u][v] = g[v][u] = max(g[u][v],len);
        }
        printf("Scenario #%d:\n",Case++);
        dijkstra(n);
    }
    return 0;
}

POJ 3268 题目链接

题意

找到n个地点到目的地的往返最短路程中的最大值（单向的路径，所以往返可能不同）

思路

跑两遍最短路，其中一个道路是原先的道路，另一个中的道路是起点终点互换的道路

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1111;
const int INF = 0x3f3f3f3f;
int lowcost[2][N],vis[N],g[2][N][N];
void dijkstra(int n,int id,int x)
{
    memset(lowcost[x],0x3f,sizeof(lowcost[x]));
    memset(vis,0,sizeof(vis));
    for (int i = 1; i <= n; i++){
        lowcost[x][i] = g[x][id][i];
    }
    vis[id] = 1;
    for (int i = 1; i < n; i++){
        int  pos = 1,mi = INF;
        for (int j = 1; j <= n; j++){
            if (!vis[j] && lowcost[x][j] < mi){
                mi = lowcost[x][j];
                pos = j;
            }
        }
        vis[pos] = 1;
        for (int j = 1; j <= n; j++){
            if (vis[j]) continue;
            if (lowcost[x][j] > lowcost[x][pos] + g[x][pos][j]){
                lowcost[x][j] = lowcost[x][pos] + g[x][pos][j];
            }
        }
    }
}
int main()
{
    int n,m,id;
    while(scanf("%d %d %d",&n,&m,&id) == 3){
        memset(g,0x3f,sizeof(g));
        for (int i = 0; i < m; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            g[0][u][v] = min(g[0][u][v],len);
            g[1][v][u] = min(g[1][v][u],len);
        }
        dijkstra(n,id,0);
        dijkstra(n,id,1);
        int ans = -INF;
        for (int i = 1; i <= n; i++){
            if (i == id) continue;
            ans = max(ans,lowcost[0][i] + lowcost[1][i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

POJ 1860 题目链接

题意

n种货币，m个兑换点，有s号货币v元
每次对话有佣金和汇率，经过一些操作后是否能够使本金变多

思路

SPFA判环

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 111;
const int INF = 0x3f3f3f3f;
double value[N][N],cost[N][N];
double ans[N];
int vis[N],cnt[N];
bool SPFA(int x,int n,double sum)
{
    memset(vis,0,sizeof(vis));
    memset(ans,0,sizeof(ans));
    memset(cnt,0,sizeof(cnt));
    queue<int> q;
    q.push(x);
    ans[x] = sum;
    vis[x] = 1;
    cnt[x] = 1;
    while(!q.empty()){
        int now = q.front();
        q.pop();
        vis[now] = 0;
        for (int i = 1; i <= n; i++){
            double tem = (ans[now] - cost[now][i]) * value[now][i];
            if (tem > ans[i]){
                ans[i] = tem;
                if (!vis[i]){
                    vis[i] = 1;
                    q.push(i);
                    cnt[i]++;
                    if (cnt[i] > n) return true;
                }
            }
        }
        if (ans[x] > sum) return true;
    }
    return false;
}
int main()
{
    int n,m,s;
    double sum;
    while(scanf("%d %d %d %lf",&n,&m,&s,&sum) == 4){
        memset(value,-1,sizeof(value));
        memset(cost,0x3f,sizeof(cost));
        for (int i = 0; i < m; i++){
            int a,b;
            double v1,v2,c1,c2;
            scanf("%d %d %lf %lf %lf %lf",&a,&b,&v1,&c1,&v2,&c2);
            value[a][b] = v1;
            cost[a][b] = c1;
            value[b][a] = v2;
            cost[b][a] = c2;
        }
        if (SPFA(s,n,sum)) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

poj 3660 题目链接

题意

有n头牛，m对胜负关系，问能确定多少头牛的排名

思路

一头牛可以打败y头牛，被x头牛打包，那么要满足x + y == n - 1就能确定他的排名
利用floyd的传递性算出所有的胜负关系

#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 111;
int g[N][N];
int lowcost[N],vis[N];
int cnt1[N],cnt2[N];
void floyd(int n)
{
    for (int k = 1; k <= n; k++){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                if (g[i][k] && g[k][j]) g[i][j] = 1;
            }
        }
    }
}
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m) == 2){
        memset(g,0,sizeof(g));
        memset(cnt1,0,sizeof(cnt1));
        memset(cnt2,0,sizeof(cnt2));
        for (int i = 0; i < m; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            g[u][v] = 1;
        }
        floyd(n);
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                if (g[i][j]) {
                    cnt1[i]++;
                    cnt2[j]++;
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= n; i++){
            if (cnt1[i] + cnt2[i] == n - 1) ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

POJ 3159 题目链接

题意

班上有n个同学，现在有一些糖要分给他们，设第i个同学得到的糖为p[i]，分糖必须满足条件：第i个同学要求第j个同学的糖不能超过自己k个，即p[j] - p[i] <= k，k >= 0。要求在满足这些条件的情况下，求出p[n] - p[1]的最大值

思路

差分约束
因为p[j] - p[i] <= k，所以p[j] <= p[i] + k;就是dijkstra的松弛操作
用queue会超时，要用stack

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 1111 + 1000000;
const int INF = 0x3f3f3f3f;
struct node{
    int to,nex,len;
}e[N];
int head[N],cnt;
int lowcost[N];
int vis[N];
void add(int u,int v,int len)
{
    e[cnt].len = len;
    e[cnt].to = v;
    e[cnt].nex = head[u];
    head[u] = cnt++;
}
int SPFA(int n)
{
    memset(lowcost,0x3f,sizeof(lowcost));
    memset(vis,0,sizeof(vis));
    stack<int> st;
    st.push(1);
    lowcost[1] = 0;
    vis[1] = 1;
    while(!st.empty()){
        int u = st.top();
        st.pop();
        vis[u] = 0;
        for (int i = head[u]; i != -1; i = e[i].nex){
            int v = e[i].to;
            if (lowcost[v] > lowcost[u] + e[i].len){
                lowcost[v] = lowcost[u] + e[i].len;
                if (!vis[v]){
                    st.push(v);
                    vis[v] = 1;
                }
            }
        }
    }
    return lowcost[n];
}
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m) == 2){
        memset(head,-1,sizeof(head));
        cnt = 0;
        for (int i = 0; i < m; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            add(u,v,len);
        }
        printf("%d\n",SPFA(n));
    }
    return 0;
}

LightOJ 1074 VJ题目链接

题意

有n个城市，每一个城市有一个拥挤度Ai，从一个城市I到另一个城市J的时间为:(Av−Au)3。问从第一个城市到达第k个城市所花的时间，如果不能到达，或者时间小于3输出？否则输出所花的时间。

思路

SPFA判断负环（floyd只能解决负边，不能解决负环）

if (leap[i] || g[u][i] == INF) continue;///少了g[u][i] == INF 就会WA（不科学）,以后还是用链式前向星吧

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 333;
const int INF = 0x3f3f3f3f;
int g[N][N];
int vis[N];
int lowcost[N];
int value[N];
int cnt[N];
int leap[N];
void dfs(int u,int n)
{
    leap[u] = 1;
    for (int i = 1; i <= n; i++){
        if (leap[i]) continue;
        if (g[u][i] != INF) dfs(i,n);
    }
}
void SPFA(int n)
{
    memset(leap,0,sizeof(leap));
    memset(lowcost,0x3f,sizeof(lowcost));
    memset(cnt,0,sizeof(cnt));
    memset(vis,0,sizeof(vis));
    queue<int> q;
    q.push(1);
    cnt[1] = 1;
    lowcost[1] = 0;
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for (int i = 1; i <= n; i++){
            if (leap[i] || g[u][i] == INF) continue;   
            if (lowcost[i] > lowcost[u] + g[u][i]){
                lowcost[i] = lowcost[u] + g[u][i];
                if (!vis[i]){
                    vis[i] = 1;
                    cnt[i]++;
                    q.push(i);
                    if (cnt[i] > n) dfs(i,n);
                }
            }
        }
    }
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        for (int i = 1; i <= n; i++){
            scanf("%d",&value[i]);
        }
        int m;
        scanf("%d",&m);
        memset(g,0x3f,sizeof(g));
        for (int i = 0; i < m; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            g[u][v] = (value[v] - value[u]) * (value[v] - value[u]) * (value[v] - value[u]);
        }
        SPFA(n);
        int q;
        scanf("%d",&q);
        printf("Case %d:\n",Case++);
        for (int i = 0; i < q; i++){
            int x;
            scanf("%d",&x);
            if (lowcost[x] < 3 || lowcost[x] == INF || leap[x]) printf("?\n");
            else printf("%d\n",lowcost[x]);
        }
    }
    return 0;
}

HDU 4728 题目链接

题意

每个点放在一层，然后给了n个点，相邻的两层距离是固定的c(假设中间有一层没有，不能进行跳跃)，有额外m条边，然后求1到n的最短路径，如果没有则输出-1

思路

建图：每一层都用一个数表示，楼层号码为[n + 1,n + n] ，这一层到这一层的所有点都为0（单向边，因为同一层的点距离不是零），这一层的所有点到上下两层都为c（建图的时候可以不需要建双向，因为楼层只是中间点，上下两层的点跑到中间层，中间层到该层的点又为0，这样就实现了上下两层的点到中间层的点距离都为c，所以中间层跑到上下两层的点的边是没必要建的）
算法实现：使用堆优化的dijkstra（优先队列实现，这里的vis数组不要也没关系，因为dijkstra中每次跑的都是最短的点，也只会经过一次，不过写总比不写安全）

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 4e5 + 5;
const int INF = 0x3f3f3f3f;
struct node{
    int to,nex,len;
}e[N * 2];
struct point{
    int id,cost;
    bool operator < (const point &p) const{
        return cost > p.cost;
    }
};
int l[N];
int lowcost[N];
int head[N],cnt;
bool vis[N];
void add(int u,int v,int len)
{
    e[cnt].to = v;
    e[cnt].len = len;
    e[cnt].nex = head[u];
    head[u] = cnt++;
}
int dijkstra(int n)
{
    memset(lowcost,0x3f,sizeof(lowcost));
    memset(vis,false,sizeof(vis));
    priority_queue<point> q;
    q.push({1,0});
    lowcost[1] = 0;
    while(!q.empty()){
        point now = q.top();
        q.pop();
        if (vis[now.id]) continue;
        vis[now.id] = true;
        for (int i = head[now.id]; i != -1; i = e[i].nex){
            int v = e[i].to;
            if (vis[v]) continue;
            if (lowcost[v] > now.cost + e[i].len){
                lowcost[v] = now.cost + e[i].len;
                q.push({v,lowcost[v]});
            }
        }
    }
    return lowcost[n] == INF ? -1 : lowcost[n];
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n,m,cost;
        scanf("%d %d %d",&n,&m,&cost);
        memset(vis,false,sizeof(vis));
        for (int i = 1; i <= n; i++){
            scanf("%d",&l[i]);
            vis[l[i]] = true;
        }
        memset(head,-1,sizeof(head));
        cnt = 0;
        for (int i = 1; i <= n; i++){
            add(l[i] + n,i,0);
            if (vis[l[i] - 1]){
                add(i,l[i] + n - 1,cost);
            }
            if (vis[l[i] + 1]){
                add(i,l[i] + n + 1,cost);
            }
        }
        for (int i = 0; i < m; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            add(u,v,len);
            add(v,u,len);
        }
        printf("Case #%d: %d\n",Case++,dijkstra(n));
    }
    return 0;
}

POJ 3169 题目链接

题意

一共有n头牛，有ml个关系好的牛的信息，有md个关系不好的牛的信息，对应输入的第一行的三个元素，接下来ml行，每行三个元素A,B,D，表示A牛和B牛相距不希望超过D，接下来md行，每行三个元素A,B,D表示A牛和B牛的相距至少要有D才行。求1号牛和n号牛的最大距离，如果距离无限大输出-2，如果无解输出-1。

思路

和POJ 3159类似，首先要建立不等式，转化为松弛操作
（1）len[A] - len[B] <= D
(2) len[A] - len[B] >= D -> len[B] - len[A] <= D

#include <queue>
#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int N = 1111;
const int M = 1e5 + 5;
struct edge{
    int to,nex,len;
}e[M];
int head[N],cnt;
int vis[N],num[N];
int lowcost[N];
void add(int u,int v,int len)
{
    e[cnt].to = v;
    e[cnt].len = len;
    e[cnt].nex = head[u];
    head[u] = cnt++;
}
int SPFA(int n)
{
    memset(lowcost,0x3f,sizeof(lowcost));
    memset(vis,0,sizeof(vis));
    memchr(num,0,sizeof(num));
    queue<int> q;
    q.push(1);
    lowcost[1] = 0;
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for (int i = head[u]; i != -1; i = e[i].nex){
            int v = e[i].to;
            if (lowcost[v] > lowcost[u] + e[i].len){
                lowcost[v] = lowcost[u] + e[i].len;
                if (!vis[v]){
                    vis[v] = 1;
                    q.push(v);
                    num[v]++;
                    if(num[v] > n) return -1;
                }
            }
        }
    }
    return lowcost[n] == INF ? -2 : lowcost[n];
}
int main()
{
    int n,ml,mr;
    while(scanf("%d %d %d",&n,&ml,&mr) == 3){
        memset(head,-1,sizeof(head));
        cnt = 0;
        for (int i = 0; i < ml; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            add(u,v,len);
        }
        for (int i = 0; i < mr; i++){
            int u,v,len;
            scanf("%d %d %d",&u,&v,&len);
            add(v,u,-len);
        }
        printf("%d\n",SPFA(n));
    }
    return 0;
}

HDU 4390 题目链接

题意

有一个C矩阵，求一个X矩阵使得 ∑ i = 1 j = 1 n ( x i j ∗ c i j ) \sum_{i=1j =1}^n(xij * cij) ∑i=1j=1n​(xij∗cij) 最小
1.x12+x13+…x1n=1
2.x1n+x2n+…x(n-1)n=1
3.对于每一个i(1 < i < n) 满足 ∑ k = 1 , i n \sum_{k=1,i}^n ∑k=1,in​. = ∑ i , j = 1 n \sum_{i,j=1}^n ∑i,j=1n​.

思路
zhe_zhenbuhui_a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BFS 解决最短路问题
2301_80035594的博客
05-23 1397
BFS（广度优先搜索）可以用于解决最短路问题，特别是当图中的边权重均为1时，BFS是一种有效的方法。文章给出算法模板和例题演练，帮助您快速掌握。
最短路模型
正在考研ing
05-22 1706
文章目录前言一、最短路二、例题，代码AcWing 1076. 迷宫问题本题分析AC代码AcWing 188. 武士风度的牛本题分析AC代码AcWing 1100. 抓住那头牛本题分析AC代码三、时间复杂度 前言 复习acwing算法提高课的内容，本篇为讲解算法：最短路模型，关于时间复杂度：目前博主不太会计算，先鸽了，日后一定补上。 一、最短路 我们在算法基础部分已经说明了几种计算最短路的方式：Dijkstra，bellman-ford，spfa，Floyd，我们也可以通过bfs去计算最短路（边权一样）.
最短路问题
m0_63024355的博客
10-17 1305
本文用到了Dijkstra算法和Floyd算法，有了解后再看更好
最短路基础与习题
weixin_43870697的博客
07-23 945
目录 前言 Floyd算法 Dijkstra算法 详解 模板 Spfa算法 详解 模板 例题 A.POJ-2387 Til the Cows Come Home B.POJ-2253 Frogger C.POJ-1797 Heavy Transportation D：POJ-3268 Silver Cow Party E:POJ-1860 Currency Exc...
最短路简介
m0_62494327的博客
03-30 804
在图论中最短路径是两个节点之间经过的边权值之和最小的路径，是一种在图上的搜索，满足最优子结构（可以使用动态规划和贪心算法）最优子结构:最短路径的子路径也是最短路径(有可以到达的负环的图不满足最优子结构)
最短路计数 学习笔记
不知所云的博客
06-11 443
最短路计数 最短路非常熟悉，但是最短路数量怎么计算呢？ 设一个计数数组sum[]; 以 dij 算法为例，当 p—>q 时，如果是可以更新最短路，那么 sum[q]=sum[p]； 如果不可以更新最短路，那么如果 dis[p]+edge[i].w==dis[q] ，说明 p 到 q 也是最短路，sum[q]+=sum[p] ; 模板题：洛谷·P1608 路径统计 代码： #include<bits/stdc++.h> #define LL long long #define pa pair
matlab最短路.txt
08-11
matlab最短路.txt
Floyd最短路
01-03
Floyd最短路matlab算法，经典的运筹学问题。hiuhoojjljljpiojupo
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 603
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 666
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 253
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【算法】插入排序
贱贱的剑
07-03 1002
介绍了两种不同的插入排序算法，以及效率对比
LSH算法：高效相似性搜索的原理与Python实现II
uncle_ll的博客
07-02 924
lsh基于随机平面的实现
详解反向传播（BP）算法
PiggyRuns的博客
07-02 1218
一文详解反向传播算法公式推导以及pytorch实现
秋招力扣刷题——从前序与中序遍历序列构造二叉树
qq_50604294的博客
07-04 207
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。：两种代码的结束条件以及分割的右区间处理方式不同，后者更容易理解一点。
Python基于卷积神经网络分类模型(CNN分类算法)实现时装类别识别项目实战
胖哥真不错的博客
07-03 1038
Python基于卷积神经网络分类模型(CNN分类算法)实现时装类别识别项目实战
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 643
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
matlab求最短路
05-24
在 MATLAB 中求解最短路问题可以使用 graphshortestpath 函数。graphshortestpath 函数可以用于求解有向图和无向图的最短路径问题，可以指定起点和终点，还可以考虑边的权重。以下是使用 graphshortestpath 函数求解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值