HDU 1385 UVA 523 （Bellman-Ford+Floyd）

最新推荐文章于 2019-01-30 21:12:00 发布
最新推荐文章于 2019-01-30 21:12:00 发布
阅读量216 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40679299/article/details/80735488
版权

其实两道题一样的，但uva的输入以及输出格式太考验人。
把hdu这道做出来后，光弄这些输入输出格式弄了两个小时。。。。。。。
不过收获蛮大的。还是自己的基础功不扎实。
总结下来又以下几点：
1.sscanf用的不熟悉。（sprintf）
2.gets用的不好。
先说HDU上的。
Bellman-Ford
其实Bellman-Ford做这个题的解析刚开始看的我挺懵的，做了我一上午才慢慢搞懂，我可真垃圾呀。一开始死活看不懂，一直不明白那块为啥是Bellman-Ford，后来又回归定义，终于想通了。
用Bellman-Ford算法解这道题关键在与这段代码：

for(int l=0;l<n-1;l++){
       for(int i=1;i<=n;i++){
             for(int k=1;k<=n;k++){
                if(i==k||cost[i][k]<0){
                    continue;
                }
                for(int j=1;j<=n;j++){
                    if(route[i][j].cost>cost[i][k]+route[k][j].cost+cost[k][k]||(route[i][j].cost==cost[i][k]+route[k][j].cost+cost[k][k]&&route[i][j].nexthop>k)){
                        //路径从小到大。 
                        route[i][j].cost=cost[i][k]+route[k][j].cost+cost[k][k];
                        route[i][j].nexthop=k;
                    }
                }
            }
        }
    }

第一个for循环不言而喻，他就是循环n-1次，跟原始的Bellman-Ford是一个道理，
第二个for循环就是表示第i个节点，第三个for循环是以k为中间节点进行松弛操作，第四个for循环是第j个节点。
所以就是求i–>j的最短路径，再加上节点上的花费。
为什么中间是用cost[i][k]做计算呢，最重要的是一个原因，因为要输出路径。
其实应用Bellman-Ford算法的思想，本身很容易将此处写成route[i][k].cost，其实这样写最后算的最短路径没问题，不信你可以拿测试样例试试，但是路径就会发生问题，
cost[i][k]保证了路径的准确性，你可以由后往前推想，k是中间节点，cost[i][k]i–>j中间没有进行过松弛，只是对后面进行了松弛，所以第一步先走到k节点，之后的变化跟前面一样，所以保证了路径的正确性，
就比如：i–>k–>s–>j
要是用cost[i][k]的话肯定不会出错，先得出s，再得出k，
然而用route[i][k].cost的话可能会导致i直接就跑到s，而把k给省略了。
付完整代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<cmath>
#include<cstdlib>
#include<list>
#include<queue>
#define mm(a,b) memset(a,b,sizeof(a))
#define ACCELERATE (ios::sync_with_stdio(false),cin.tie(0))
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
#define MAXN 0x3fffffff
#define PI acos(-1.0)
#define E exp(1.0)
using namespace std;

//#define debug

struct node{
    int cost;
    int nexthop;
};

node route[300][300];

int cost[300][300];

int n;

bool getmap(){
    scanf("%d",&n);
    if(n==0) return 0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%d",&cost[i][j]);
        }
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&cost[i][i]);
    }
    return 1;
}

void init_map(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j){
                route[i][j].cost=0;
                route[i][j].nexthop=j;
                continue;
            }
            if(cost[i][j]<0){
                route[i][j].cost=MAXN;
                route[i][j].nexthop=-1;
            }else{
                route[i][j].cost=cost[i][j];
                route[i][j].nexthop=j;
            }
        }
    }
    for(int l=0;l<n-1;l++){
       for(int i=1;i<=n;i++){
             for(int k=1;k<=n;k++){
                if(i==k||cost[i][k]<0){
                    continue;
                }
                for(int j=1;j<=n;j++){
                    if(route[i][j].cost>cost[i][k]+route[k][j].cost+cost[k][k]||(route[i][j].cost==cost[i][k]+route[k][j].cost+cost[k][k]&&route[i][j].nexthop>k)){
                        //路径从小到大。 
                        route[i][j].cost=cost[i][k]+route[k][j].cost+cost[k][k];
                        route[i][j].nexthop=k;
                    }
                }
            }
        }
    }
}

void solve(){
    int from,to,f;
    while(scanf("%d%d",&from,&to)==2&&from>0){
        printf("From %d to %d :\n",from,to);
        printf("Path: %d",from);
        if(from!=to){
            for(f=route[from][to].nexthop;f!=to;f=route[f][to].nexthop){
                printf("-->%d",f);
            }
            printf("-->%d",to);
        }
        printf("\n");
        printf("Total cost : %d\n\n",route[from][to].cost);
    }
}

int main()
{
    #ifdef debug
    freopen("in.txt","r",stdin);
    freopen("out2.txt","w",stdout);
    #endif // debug

    while(getmap()){
        init_map();
        solve();
    }
    return 0;
}

Floyd
其实这个跟上面那个的时间复杂度相差无几，但这个好理解得多。
刚来开始就一直想用Floyd写的，苦于不知道路径怎么输出。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<cmath>
#include<cstdlib>
#include<list>
#include<queue>
#define mm(a,b) memset(a,b,sizeof(a))
#define ACCELERATE (ios::sync_with_stdio(false),cin.tie(0))
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
#define MAXN 0x3fffffff
#define PI acos(-1.0)
#define E exp(1.0)
using namespace std;

//#define debug

int cost[300][300];
int pre[300][300];
int tax[300];

int n;

bool getmap(){
    scanf("%d",&n);
    if(n==0) return 0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%d",&cost[i][j]);
            if(cost[i][j]==-1) cost[i][j]=MAXN;
        }
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&tax[i]);
    }
    return 1;
}

void floyd(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            pre[i][j]=j;
        }
    }
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(cost[i][k]>0&&cost[k][j]>0){
                        if(cost[i][j]>cost[i][k]+cost[k][j]+tax[k]){
                        cost[i][j]=cost[i][k]+cost[k][j]+tax[k];
                        pre[i][j]=pre[i][k];
                    }
                    else if(cost[i][j]==cost[i][k]+cost[k][j]+tax[k]){
                        pre[i][j]=min(pre[i][k],pre[i][j]);
                    }
                }
            }
        }
    }
}

void solve(){
    int from,to,f;
    while(scanf("%d%d",&from,&to)==2&&from>0){
        printf("From %d to %d :\n",from,to);
        printf("Path: %d",from);
        if(from!=to){
            for(f=pre[from][to];f!=to;f=pre[f][to]){
                printf("-->%d",f);
            }
            printf("-->%d",to);
        }
        printf("\n");
        printf("Total cost : %d\n\n",cost[from][to]);
    }
}

int main()
{
    #ifdef debug
    freopen("in.txt","r",stdin);
    freopen("out2.txt","w",stdout);
    #endif // debug

    while(getmap()){
        floyd();
        solve();
    }
    return 0;
}

uva就跟hdu思想一摸一样。就是输入输出格式变了

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<cmath>
#include<cstdlib>
#include<list>
#include<queue>
#define mm(a,b) memset(a,b,sizeof(a))
#define ACCELERATE (ios::sync_with_stdio(false),cin.tie(0))
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
#define MAXN 0x3fffffff
#define PI acos(-1.0)
#define E exp(1.0)
using namespace std;

//#define debug

struct node{
    int cost;
    int nexthop;
};

node route[1025][1025];

int cost[1025][1025];
int casei;

int n;
char str[1025];

void  getmap(){
    n=0;
    char ch;
    int ans=0;
    int flag=1;
    while(gets(str)&&!str[0]);
    int len=strlen(str);
    str[len]=' ';
    str[len+1]=0;
    for(int i=0;str[i];i++){
        if(isdigit(str[i]))
            ans=ans*10+str[i]-'0';
        else if(str[i]=='-') flag=-1;
        else {
            cost[1][++n]=ans*flag;
            flag=1;ans=0;
        }
    }
    for(int i=2;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%d",&cost[i][j]);
        }
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&cost[i][i]);
    }
    getchar();
}

void init_map(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j){
                route[i][j].cost=0;
                route[i][j].nexthop=j;
                continue;
            }
            if(cost[i][j]<0){
                route[i][j].cost=MAXN;
                route[i][j].nexthop=-1;
            }else{
                route[i][j].cost=cost[i][j];
                route[i][j].nexthop=j;
            }
        }
    }
    for(int l=0;l<n-1;l++){
        for(int i=1;i<=n;i++){
            for(int k=1;k<=n;k++){
                if(i==k||cost[i][k]<0){
                    continue;
                }
                for(int j=1;j<=n;j++){
                    if(route[i][j].cost>cost[i][k]+route[k][j].cost+cost[k][k]||(route[i][j].cost==cost[i][k]+route[k][j].cost+cost[k][k]&&route[i][j].nexthop>k)){
                        route[i][j].cost=cost[i][k]+route[k][j].cost+cost[k][k];
                        route[i][j].nexthop=k;
                    }
                }
            }
        }
    }
}


void solve(){
    int from,to,f;

    while(gets(str)&&str[0]){
        sscanf(str,"%d%d",&from,&to);
        if (casei ++) {
                puts("");
            }
        printf("From %d to %d :\n",from,to);
        printf("Path: %d",from);
        if(from!=to){
            for(f=route[from][to].nexthop;f!=to;f=route[f][to].nexthop){
                printf("-->%d",f);
            }
            printf("-->%d",to);
        }
        printf("\n");
        printf("Total cost : %d\n",route[from][to].cost);
    }
}

int main()
{
    #ifdef debug
    freopen("in.txt","r",stdin);
//    freopen("out2.txt","w",stdout);
    #endif // debug
    int m;
    scanf("%d",&m);
    while(m--){
        getmap();
        init_map();
        solve();
    }

    return 0;
}
兜率工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bellman-Ford算法
TimeMagician的博客
06-29 473
参考： Single-Source Shortest Path：Bellman-Ford Algorithm SPFA——基于Bellman-Ford的队列优化 How is the Bellman Ford algorithm a case of dynamic programming? Shortest Path and Dynamic Programming Algorithms ...
HDU+2000-2099+解题报告
08-31
3. **图论**：包括最短路径算法（Dijkstra、Floyd-Warshall、Bellman-Ford）、最小生成树（Prim、Kruskal）、拓扑排序等。 4. **字符串处理**：如KMP算法、Manacher's Algorithm、后缀数组、Z-Algorithm等，常用于...
UVa 523 - Minimum Transport Cost
小白菜又菜
04-21 891
題目：在幾個城市間運送貨物，每個城市間的道路有固定的花費，             經過某個特定城市也有一個固定的花費，求最小代價和路徑。 分析：圖論、最短路。使用floyd算法求解多元最短路記錄路徑即可。             記錄每個節點的後繼既可以保存路徑； 說明：這道題真的很想吐槽：             1、輸入的格式沒有城市個數，需要字符串轉成數字統計個數；      
uva 1385 - Billing Tables(字典树)
不慌不忙、不急不躁
09-05 1737
题目链接：uva 1385 - Billing Tables 题目大意：给定n个电话前缀，每个前缀是一个区域的前缀，现在要生成一个新的电话单，即对于每个电话号码，从旧的电话单上从前向后遍历，如果出现前缀匹配，则该电话号码对应的即为当前的区号，要求生成的新电话单尽量小。 解题思路：用dfs建立字典树，在区间范围内的点对应均为对应的区号，注意如果70、71、72、...79都为SB的话，那
UVA - 11107 Life Forms (广义后缀自动机)
weixin_30609331的博客
01-30 78
题意：给你n个字符串，求出在超过一半的字符串中出现的所有子串中最长的子串，按字典序输出。 对这n个字符串建广义后缀自动机，建完后每个字符串在自动机上跑一遍，沿fail树向上更新所有子串结点的出现次数(指在n个字符串中的多少个串中出现，用siz表示)，用vis数组判重，最后dfs输出结果就好了。 【后记】这个代码似乎有bug，被我自己给hack了...建议暴力对字典序排序 1 #incl...
最短路算法详解（Dijkstra/SPFA/Floyd）
热门推荐
a20180825的博客
08-07 1万+
最短路算法详解：Dijkstra、SPFA、Floyd
HDU+2000-2099+解题报告.zip
02-11
《杭电OnlineJudge 2000-2099解题报告》是针对杭州电子科技大学（HDU）在线评测系统（OnlineJudge）中2000至2099题目的详细解答集锦，主要涵盖了算法分析、编程技巧以及问题解决策略等内容。这份解题报告以CHM...
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
HDU-EID-V2-扩展板1
08-04
HDU-EID-V2-扩展板1是一款专为STM32微控制器设计的硬件扩展板，主要用于增强核心板的功能。该扩展板具有多种接口和功能，包括ADC（模数转换器）、电位器、DAC（数模转换器）输出以及TEST_V跳线，能够满足用户在模拟...
武汉科技大学在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
mysql安装配置教程.zip
09-07
mysql安装配置教程
SWAT模型-全国河流水文站坐标
09-07
全国河流水文站坐标
天津师范大学在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
西安立人智慧教育解决方案.pdf
最新发布
09-07
西安立人智慧教育解决方案.pdf
东北石油大学在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
国内期货保证金比例与手续费列表（测试）
09-07
国内期货保证金比例与手续费列表（测试），用于期货量化软件开发测算保证金与手续费用，注意里面的值只是一些测试值，实际使用时，还需要和自己开户的期货公司和期货公司的给与的政策相结合，才能更准确的测算开仓保证金数量，手续费水平。也可以做为回策时的参考比率，提高策略回测的准确性。
一款纯VF控制的变频器方案方案说明:可做0.2KW7.5KW 220V，0.2KW75KW 380V，富士通MB90F462A
09-07
一款纯VF控制的变频器方案方案说明:可做0.2KW7.5KW 220V，0.2KW75KW 380V，富士通MB90F462A LQFP64单片机控制，可提供源码及电路原理图，PCB图 这是一种基于纯VF控制的变频器方案。它可以在220V电压下提供0.2KW到7.5KW的功率输出，或者在380V电压下提供0.2KW到75KW的功率输出。该方案采用了富士通MB90F462A LQFP64单片机进行控制，并且提供了源码、电路原理图和PCB图。 知识点和领域范围： - 变频器：变频器是一种电力电子设备，用于控制交流电机的转速和输出功率。它通过改变输入电压的频率和幅值，实现对电机的调速控制。 - VF控制：VF控制是一种变频器控制方式，通过同时改变电压和频率的比例，实现对电机转速的精确控制。 - 单片机控制：单片机是一种集成电路芯片，具有处理器、存储器和输入输出接口等功能。它可以用于控制和管理各种电子设备，包括变频器。 - 源码：源码是计算机程序的原始代码，通常以文本形式表示。它包含了程序的逻辑和算法，可以被编译器或解释器转换为可执行的机器代码。 - 电路原理图：电路原理图是一种
青岛大学在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值