ACM之最短路径做题笔记与记录

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量110 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Anani-leaf/p/5563433.html
版权

在这里纪念一下从4月开始一直因为事情而荒废了的最短路,多亏了jbb的帮助,我才完成了FZU热身赛一题简单的一个用模拟链表存边以及最短路径的学习,目前(6.5)已经学会使用了最简单的djstral与spfa，以及优先队列优化的dj,这里是最近2天做出来的题目,在这里记录一下

HUD1221 HDU Today

这题需要注意的就是可能存在回路,头尾一个点

//dijkstral + 动态数组
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<map>
using namespace std;
const int INF = 10000000;
struct E
{
    int to;
    int d;
};
int main()
{
    int N;
    while (scanf("%d",&N),N!=-1)
    {
        char s1[100],s2[100];
        vector<E>head[160];
        map<string,int> mp;
        scanf("%s %s",s1,s2);
        mp[s1] = 1;
        mp[s2] = 2;
        int len = 3;
        bool flag = strcmp(s1,s2) == 0;
        for (int i = 1; i < N + 1; i++)
        {
            int d;
            scanf("%s %s %d",s1,s2,&d);
            if(!mp[s1])
            {
                mp[s1] = len++;
            }
            if(!mp[s2])
            {
                mp[s2] = len++;
            }
            
            int u = mp[s1];
            int v = mp[s2];
            
            E tmp;
            tmp.d = d;
            
            tmp.to = u;
            head[v].push_back(tmp);
            
            tmp.to = v;
            head[u].push_back(tmp);
            
        }
        if(flag)
        {
            printf("0\n");
            continue;
        }
        
        int d[160];
        bool vis[160] = {false}; 
        fill(d,d+160,INF);
        d[1] = 0;
        while(true)
        {
            
            int nod = -1;
            for(int i = 1 ; i < len; i++)
            {
                if(!vis[i] && (nod == -1 || d[nod] > d[i]))
                {
                    nod = i;
                }
            }
            
            if(nod == -1) break;
            vis[nod] = true;
            for (int i = 0; i < head[nod].size(); i++)
            {
                if(d[head[nod][i].to] > d[nod] + head[nod][i].d)
                {
                    d[head[nod][i].to] =  d[nod] + head[nod][i].d;
                }
            }
        }
        if(d[2] == INF)
        {
            printf("-1\n");
            
        }
        else
        printf("%d\n",d[2]);
    }
}
//dijkstral + 模拟链表
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue> 
#include<map>
using namespace std;
const int INF = 10000000;
struct E
{
    int to;
    int d;
    bool operator < (const E &T) const
    {
        return d < T.d;
    }
};
int main()
{
    int N;
    while (scanf("%d",&N),N!=-1)
    {
        char s1[100],s2[100];
        vector<E>head[160];
        map<string,int> mp;
        scanf("%s %s",s1,s2);
        mp[s1] = 1;
        mp[s2] = 2;
        int len = 3;
        bool flag = strcmp(s1,s2) == 0;
        for (int i = 1; i < N + 1; i++)
        {
            int d;
            scanf("%s %s %d",s1,s2,&d);
            if(!mp[s1])
            {
                mp[s1] = len++;
            }
            if(!mp[s2])
            {
                mp[s2] = len++;
            }
            
            int u = mp[s1];
            int v = mp[s2];
            
            E tmp;
            tmp.d = d;
            
            tmp.to = u;
            head[v].push_back(tmp);
            
            tmp.to = v;
            head[u].push_back(tmp);
            
        }
        
        if(flag)
        {
            printf("0\n");
            continue;
        }
        
        int d[160];
        fill(d,d+160,INF);
        d[1] = 0;
        priority_queue<E> que;
        E tmp;
        tmp.d = 0;
        tmp.to = 1;
        que.push(tmp);
        
        while (!que.empty())
        {
            tmp = que.top();
            que.pop();
            int u = tmp.to;
            if(d[u] < tmp.d) continue;
            
            for(int i = 0; i < head[u].size(); i++)
            {
                int v = head[u][i].to;
                if(d[v] > d[u] + head[u][i].d)
                {
                    d[v] = d[u] + head[u][i].d;
                    E ttt;
                    
                    ttt.d = d[v];
                    ttt.to = v;
                    
                    que.push(ttt);
                }
            }
        }
        
        
        if(d[2] == INF)
        {
            printf("-1\n");
            
        }
        else
        printf("%d\n",d[2]);
    }
}

//SPFA
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <stack>
//lower_bound(a+1,a+1+len1,x) - a - 1;
typedef long long LL;
const int INF = 10000000;
using namespace std;
struct E
{
    int cost;
    int nod;
};

int main()
{
//    freopen("xx.in","r",stdin);
//    freopen("xx.out","w",stdout);
    int N;
    while (scanf("%d",&N),N!=-1)
    {
        char a[100],b[100];
        bool flag = false;

        E edge[20010];
        map<string,int> mp;
        scanf("%s %s",a,b);
        if(strcmp(a,b) == 0) flag = true;
        mp[a] = 1;
        mp[b] = 2;
        int len = 3;
        vector<int> head[160];
        for (int i = 1; i < N + 1 ; i++)
        {
            int d;
            scanf("%s %s %d",a,b,&d);

            if(!mp[a])
            {
                mp[a] = len++;
            }
            if(!mp[b])
            {
                mp[b] = len++;
            }

            int u = mp[a];
            int v = mp[b];

            head[u].push_back(i);
            edge[i].cost = d;
            edge[i].nod = v;

            head[v].push_back(i+N);
            edge[i+N].cost = d;
            edge[i+N].nod = u;

        }

        queue<int> que;
        int d[160];
        fill(d,d+160,INF);
        d[1] = 0;
        que.push(1);
        bool vis[160]  = {false};
        vis[1] = true;
        while(!que.empty())
        {

            int u = que.front();
            vis[u] = false;
            que.pop();
            for (int i = 0; i < head[u].size(); i++)
            {
                int t = head[u][i];
                if(d[edge[t].nod] > d[u] + edge[t].cost)
                {
                    d[edge[t].nod] = d[u] + edge[t].cost;
                    if(!vis[edge[t].nod])
                    {
                        vis[edge[t].nod] = true;
                        que.push(edge[t].nod);
                    }
                }
            }
        }
        if(flag)
        {
            printf("0\n");
        }
        else
        {
            if(d[2] == INF)
            {
                printf("-1\n");
            }
            else
            {
                printf("%d\n",d[2]);
            }
        }
    }
    return 0;
}

HDU 1217 Arbitrage

这题比较有意思,我一开始不会做,题意大概是,给你N个货币类型,接下来M个货币兑换,问你是否存在一种情况,结果多次兑换后,你可以赚钱,比如一开始美元是1,你换来换去后可以把1美元变成大于1美元的情况...
这题据说不可以用djkstral,因为乘法中,小于1表示有负环,..所以用SPFA来弄,当然Floyd也可以,不过我还并不会...

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <queue>
#include <map>
#include <stack>
//lower_bound(a+1,a+1+len1,x) - a - 1;
typedef long long LL;

using namespace std;
vector<int>head[40];
struct E
{
    double cost;
    int nod;
}edge[10000];
bool SPFA(int start)
{
    bool vis[40] = {false};
    double d[40] = {0};
    d[start] = 1.0;
    queue<int> que;
    que.push(start);
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        vis[u] = false;
        for (int i = 0; i < head[u].size(); i++)
        {
            int t = head[u][i];//边
            int v = edge[t].nod;
            double cost = edge[t].cost;
            if(d[v] < d[u]*cost)
            {
                d[v] = d[u]*cost;
                vis[v] = true;
                que.push(v); 
            } 
        }
        
        if(d[start] > 1.0)
        {
            return true;
         } 
    }
    return false;
}
int main()
{
//    freopen("xx.in","r",stdin);
//    freopen("xx.out","w",stdout);
    int N;
    int T = 1;
    while(scanf("%d",&N)!=EOF && N > 0)
    {
        char a[100],b[100];
        memset(edge,0,sizeof(0));
        map<string,int>mp;
        for(int i = 0; i < 40; i++) head[i].clear();
        
        for (int i = 1; i < N + 1; i++)
        {
            scanf("%s",a);
            mp[a] = i;
        }
        int M;
        double cost;
        scanf("%d",&M);
        for (int i = 1; i < M + 1 ; i++)
        {
            scanf("%s %lf %s",a,&cost,b);
            int u = mp[a];
            int v = mp[b];
            
            head[u].push_back(i);
            edge[i].cost = cost;
            edge[i].nod = v;
        }
        bool flag = false;
        for (int i = 1; i < N+1; i++)
        {
            if(SPFA(i))
            {
                flag = true;
                break;
            }
        }
        printf("Case %d: ",T++);
        if(flag) printf("Yes\n");
        else printf("No\n"); 
        
    }
    return 0;
}

HUD 1874畅通工程续

也是裸题

//SPFA
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <stack>
//lower_bound(a+1,a+1+len1,x) - a - 1;
typedef long long LL;

using namespace std;

const int INF = 10000000;
struct E
{
    int to;
    int cost;
};
int main()
{
//    freopen("xx.in","r",stdin);
//    freopen("xx.out","w",stdout);
    int M,N;
    while (scanf("%d %d",&N,&M)!=EOF)
    {    
        E edge[20020];
        vector<int> head[205];
        for(int i = 1 ; i <= M; i++)
        {
            int u,v,d;
            scanf("%d%d%d",&u,&v,&d);
            
            head[u].push_back(i);
            edge[i].to = v;
            edge[i].cost = d;
            
            head[v].push_back(i+M);
            edge[i+M].to = u;
            edge[i+M].cost = d;
        }
        int S,T;
        scanf("%d%d",&S,&T);
        int d[205];
        fill(d,d+205,INF);
        d[S] = 0;
        queue<int> que;
        bool vis[205] = {false};
        que.push(S);
        while(!que.empty())
        {
            int u = que.front();
            que.pop();
            vis[u] = false;
            for (int i  = 0; i < head[u].size(); i++)
            {
                int v = edge[head[u][i]].to;
                int cost = edge[head[u][i]].cost;
                if(d[v] > d[u] + cost)
                {
                    d[v] = d[u] + cost;
                    if(!vis[v])
                    {
                        vis[v] = true;
                        que.push(v);
                    }
                    
                }
            }
        }
        if(d[T] == INF)
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",d[T]);
        }
        
    }
    return 0;
}

HUD 2544最短路

同样裸题

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <stack>
//lower_bound(a+1,a+1+len1,x) - a - 1;
typedef long long LL;

using namespace std;

const int INF = 10000000;
struct E
{
    int to;
    int cost;
};
int main()
{
//    freopen("xx.in","r",stdin);
//    freopen("xx.out","w",stdout);
    int M,N;
    while (scanf("%d %d",&N,&M),M||N)
    {    
        E edge[20020];
        vector<int> head[205];
        for(int i = 1 ; i <= M; i++)
        {
            int u,v,d;
            scanf("%d%d%d",&u,&v,&d);
            
            head[u].push_back(i);
            edge[i].to = v;
            edge[i].cost = d;
            
            head[v].push_back(i+M);
            edge[i+M].to = u;
            edge[i+M].cost = d;
        }
        int d[205];
        fill(d,d+205,INF);
        d[1] = 0;
        queue<int> que;
        bool vis[205] = {false};
        que.push(1);
        while(!que.empty())
        {
            int u = que.front();
            que.pop();
            vis[u] = false;
            for (int i  = 0; i < head[u].size(); i++)
            {
                int v = edge[head[u][i]].to;
                int cost = edge[head[u][i]].cost;
                if(d[v] > d[u] + cost)
                {
                    d[v] = d[u] + cost;
                    if(!vis[v])
                    {
                        vis[v] = true;
                        que.push(v);
                    }
                    
                }
            }
        }
        printf("%d\n",d[N]);
        
    }
    return 0;
}

更新日志

|时间 | 更新模块 |
|---------------- | ----------- --- |
|6.5 | 3道裸题 |
|6.6 | 1道裸题 |

转载于:https://www.cnblogs.com/Anani-leaf/p/5563433.html

weixin_30367945
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
buuctf 救世捷径(最短路dijkstra算法)
weixin_44110537的博客
08-12 1211
题目的意思是要我们求从国家1到国家26的最短路路径.这里采用dijkstra算法 dijkstra算法 dijkstra算法采用的是贪心算法的策略.大体意思是将所有点分成两个点集,一个是已经确定了到起始点的最短距离的点的集合,一个是还未确定的集合. 分别记为 A B 初始化各点到起始点的距离为无穷大(足够大)记为dv[i]:点i到起点的距离.记graph[i][j]为输入的点i到点j的距离(如果没有则记为无穷大) 1,首先可以将起始点a1加入A 2,然后将所有点到a1的距离做比较,取最小的那个点记为a2加入
ctf-----这个看起来有点简单
lsimisama的博客
12-24 845
在链接后加上单引号可知数据库为mysql 在链接后加 and 1=1 测试，返回结果正常 在链接后加 and 1=2 测试，返回结果异常，此链接存在注入，打开sqlmap输入
buuctf 救世捷径【dijkstra算法】【单源最短路径算法】
amber_o0k的博客
12-08 745
max=2000 graph=[[max] * 27 for _ in range(27)] #读取节点信息 f=open('dj.txt','r').readlines() #存入列表 for x in f: a,b,c,d=x.strip().split(' ') graph[int(a)][int(b)]=int(c) graph[int(b)][int(a)]=int(c) temp1=[True for a in range(27)] zuixiao=[0 f...
最短路径之Dijkstra(迪杰斯特拉)算法（无向图）
热门推荐
长臂人猿的博客
01-08 6万+
简介 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。由for循环可知，其时间复杂度是O（n^2）。 原理 在已知图的邻接矩阵net.vexs[i][j](无向网，含权值的图)的条件下，通过遍历已知图的所有路径，用dis[i]数组来记录到i点...
最短路径--dijkstra算法、弗洛伊德（Floyd）算法（带路径输出）
我爱加菲猫
06-09 2万+
最短路径 求最短路径重要性不言而喻，下面直接分析两个算法。 分类： 1：从某个源点到其余个点的最短路径 迪杰斯特拉（Dijkstra）算法 2：每一对之间的最短路径 弗洛伊德（Floyd）算法 一：存储结构 邻接矩阵（这里不再重复讲了，请参考）： https://blog.csdn.net/weixin_39956356/article/details/80470091 相关代...
acm-最短路径算法
weixin_43460331的博客
05-22 467
最短路径算法 一、求出最短路径的长度 以下没有特别说明的话，dis[u][v]表示从u到v最短路径长度，w[u][v]表示连接u，v的边的长度。1.Floyed-Warshall算法 O(N3) 　　 简称Floyed(弗洛伊德)算法，是最简单的最短路径算法，可以计算图中任意两点间的最短路径。Floyed的时间复杂度是O (N3)，适用于出现负边权的情况。 算法描述： 初始化：点u、v如...
ACM——街区最短路径问题
yang_china的博客
04-01 393
南阳理工ACM pro.7:http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=7街区最短路径问题时间限制：3000 ms  |  内存限制：65535 KB难度：4描述一个街区有很多住户，街区的街道只能为东西、南北两种方向。住户只可以沿着街道行走。各个街道之间的间隔相等。用(x,y)来表示住户坐在的街区。例如（4,20），表示用户在东西方向第4...
图的结构建立与最短路径算法
12-01
图的结构建立与最短路径算法是图论中两个核心概念，主要应用于网络优化、路径规划等领域。本文将深入探讨这两个主题。 首先，我们来理解什么是图的结构建立。图是由顶点（或节点）和边（或弧）构成的数据结构，用来...
历年acm程序设计试题与解答.rar
07-24
图论中的最小生成树、最短路径算法等则是解决网络优化问题的关键。 其次，ACM竞赛强调团队协作和时间管理，因为比赛现场要求团队在五小时内解决多道难题。这就需要参赛者具备快速阅读和理解题目、设计高效算法、...
ACM 程序设计：图论2 最短路径 差分约束系统-p1.pdf
06-18
图论与最短路径算法在 ACM 程序设计中的应用 在 ACM 程序设计中，图论和最短路径算法是两大重要的知识点。本文将通过一个具体的例子来介绍这两个概念，并对其在程序设计中的应用进行详细的解释。 一、图论基础 ...
ACM 程序设计：图论2 最短路径 差分约束系统-p6.pdf
06-18
在ACM程序设计中，图论是一门重要的理论基础，特别是在解决实际问题时，如本题所述的"最短路径"和"差分约束系统"。在这个特定的问题中，我们面临的是一个寻找最安全路径的问题，而非通常意义上的最短路径。问题背景...
ACM 程序设计：图论2 最短路径 差分约束系统-1.pdf
06-18
【ACM程序设计：图论2 最短路径 差分约束系统-1.pdf】这篇文档主要探讨了在图论中的最短路径问题，并且引入了差分约束系统这一概念，这是在解决某些优化问题时非常重要的工具。在这个特定的问题中，最短路径问题被...
其他CTF题目（记录备忘）
技术学习人生
08-30 3701
1、ISG2014 SQLMAP Misc 100 附件文件下载：http://www.2cto.com/uploadfile/2014/1013/20141013055722355.zip 题目给了一个sqlmap数据包，查看发现是通过逐位猜解的方式获得key，语句类似/message.php?id=1 AND ORD(MID((SELECT IFNULL(CAST(`value` AS CH
#1081 : 最短路径·一（Dijkstra）
tb_youth的博客
03-18 277
#1081 : 最短路径·一 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 万圣节的早上，小Hi和小Ho在经历了一个小时的争论后，终于决定了如何度过这样有意义的一天——他们决定去闯鬼屋！ 在鬼屋门口排上了若干小时的队伍之后，刚刚进入鬼屋的小Hi和小Ho都颇饥饿，于是他们决定利用进门前领到的地图，找到一条通往终点的最短路径。 鬼屋中一共有N个地点，分别编号为1…N，这...
CTF之302重定向
King
09-13 6245
首先，让我们来了解一下，什么是302重定向。 百度百科定义如下： 302重定向又称之为暂时性转移(Temporarily Moved )，英文名称：302 redirect。 也被认为是暂时重定向（temporary redirect），一条对网站浏览器的指令来显示浏览器被要求显示的不同的URL，当一个网页经历过短期的URL的变化时使用。一个暂时重定向是一种服务器端的重定向，能够被搜索引擎蜘蛛...
最短路径（一）——多源最短路径
AIGC | 智能洞察，创造未来
03-11 6999
多源最短路径
djkstra最短路径算法
Ray的博客
09-07 1316
在解决有多种标尺的最短路径问题中，即当具有相同的最短路径要让总的花费最小等，有两种解决问题的模板代码，一种是直接用Dijkstra算法：只需要增加一个数组来存放新增的边权或点权或最短路径条数，然后在算法中修改优化d[v]的那个步骤即可，其他部分不需要改动；一种是使用Dijkstra+dfs：先在Dijkstra算法中记录所有的最短路径（只考虑距离），然后从这些最短路径中选出一条第二标尺最优的路径。...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 257
C语言 | Leetcode C语言题解之第337题打家劫舍III
ACM程序设计：最短路径与差分约束系统实战指南
"ACM程序设计：图论2 最短路径 差分约束系统-p6.pdf" 这篇资料主要探讨了在ACM（国际大学生程序设计竞赛）中的图论问题，特别是如何寻找图中的最短路径，并引入了差分约束系统这一概念。资料以电影《Blues Brothers...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值