【dp】POJ 1661 hlep Jimmy 题解

最新推荐文章于 2020-09-29 19:03:42 发布
最新推荐文章于 2020-09-29 19:03:42 发布
阅读量408 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011523796/article/details/41226307
版权

记忆化DP：

 

//http://blog.csdn.net/alalalalalqp/article/details/9206299
#include<stdio.h>
#include<algorithm>
#include<string.h>
#define INF 0x7f7f7f
using namespace std;
struct Node {
    int xl,xr,h;
} a[1009];
int min(int a,int b) {
    if(a>b) return b;
    else return a;
}
int N,Max,dp[1009][2];
bool cmp(Node aa,Node bb) {
    return aa.h>bb.h;
}
int Time(int t,bool left) {
    int x=0;
    int y=a[t].h;
    if(left==true)
        x=a[t].xl;
    if(left==false)
        x=a[t].xr;
    int i;
    for(i=t+1; i<=N; i++) {
        if(a[i].xl<=x&&a[i].xr>=x&&a[t].h!=a[i].h) break;
    }
    if(i<=N) {
        if( y - a[i].h > Max )
            return INF;
    } else {
        if( y > Max )
            return INF;
        else
            return 0;
    }
    if(dp[i][0]==-1) {
        dp[i][0]=Time(i,true);
    }
    if(dp[i][1]==-1) {
        dp[i][1]=Time(i,false);
    }
    int lenl=(x-a[i].xl)+dp[i][0];
    int lenr=(a[i].xr-x)+dp[i][1];
    return lenl>lenr?lenr:lenl;
}
int main() {
    int t,x,y;
    scanf("%d",&t);
    while(t--) {
        scanf("%d %d %d %d",&N,&x,&y,&Max);
        a[0].h=y;
        a[0].xl=x;
        a[0].xr=x;
        for(int i=1; i<=N; i++) {
            scanf("%d %d %d",&a[i].xl,&a[i].xr,&a[i].h);
        }
        sort(a,a+N+1,cmp);
        memset(dp,-1,sizeof(dp));
        printf("%d\n",Time(0,true)+y);
    }
    return 0;
}

 

 

 

 

 

DP1：

由于从Jimmy出发。当第i快木板左右两个端点出发都找到下一块木板j时，没必要在向下找下去，因为最先找到的肯定是最优的，在j一下的木板肯定要通过当前这个最优的向下

走，则i就没必要在向下做了，应当由j向下做。

 

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <math.h>
using namespace std;
#define MAX_VAL 999999999

typedef struct {
    int height;
    int left;
    int right;
} Board;

bool cmp(const Board &b1, const Board &b2) {
    return b1.height > b2.height;
}
int main() {
    //dp[i][0]代表走到第i个木板左端的最少时间，dp[i][1]代表走到第i个木板右端的最少时间
    int dp[1005][2];
    Board board[1005];
    int nCase, x, y, MAX, n, ans;
    scanf("%d", &nCase);
    while(nCase--) {
        memset(dp, 0, sizeof(dp));
        ans = MAX_VAL;
        scanf("%d%d%d%d", &n, &x, &y, &MAX);
        for (int i = 1; i <= n; i++) {
            scanf("%d%d%d", &board[i].left, &board[i].right, &board[i].height);
            dp[i][0] = dp[i][1] = MAX_VAL;
        }
        board[0].height = y;
        //把起点当成长度为0高度为y的平台，因为有可能直接从起点下落到地面
        board[0].left = board[0].right = x;
        //按照高度从高到低排序
        sort(board, board + n + 1, cmp);
        board[n + 1].height = 0;
        board[n + 1].left = -20000;
        board[n + 1].right = 20000;
        dp[0][0] = 0;
        dp[0][1] = 0;
        for (int i = 0; i <= n; i++) {
            //bleft和bright用于标记从第i块木板左右两端下落是否找到了下一个落脚点
            bool bleft = true, bright = true;
            for (int j = i + 1; j <= n + 1; j++) {
                //如果两端都找到了落脚点或者下落的距离大于MAX则退出循环
                if (!bleft && !bright || board[i].height - board[j].height > MAX) {
                    break;
                }
                if (board[j].left <= board[i].left && board[j].right >= board[i].left && board[i].height != board[j].height && bleft) {
                    bleft = false;
                    if (j == n + 1) {
                        //如果到了地面，则直接记录下最小时间
                        ans = min(ans, dp[i][0]);
                    } else {
                        //在这里dp[j][0]表示从第i块木板左端下落，走到第j块左端的最小时间
                        dp[j][0] = min(board[i].left - board[j].left + dp[i][0], dp[j][0]);
                        //在这里dp[j][1]表示从第i块木板左端下落，走到第j块右端的最小时间
                        dp[j][1] = min(board[j].right - board[i].left + dp[i][0], dp[j][1]);
                    }
                }
                if (board[j].left <= board[i].right && board[j].right >= board[i].right && board[i].height != board[j].height && bright) {
                    bright = false;
                    if (j == n + 1) {
                        ans = min(ans, dp[i][1]);
                    } else {
                        //在这里dp[j][0]表示从第i块右端木板下落，走到第j块左端的最小时间
                        dp[j][1] = min(board[j].right - board[i].right + dp[i][1], dp[j][1]);
                        //在这里dp[j][0]表示从第i块右端木板下落，走到第j块左端的最小时间
                        dp[j][0] = min(board[i].right - board[j].left + dp[i][1], dp[j][0]);
                    }
                }
            }
        }
        printf("%d\n", ans + y);//总距离为横向加上纵向的距离，纵向的总距离则为y
    }
    return 0;
}


DP2：

 

非常暴力：

 

#include<stdio.h>
#include<algorithm>
#include<string.h>
#define INF 0x7f7f7f
using namespace std;
struct Node {
    int xl,xr,h;
} a[1009];
int dp[1009][2];
bool cmp(Node aa,Node bb) {
    return aa.h>bb.h;
}
int main() {
    int t,N,x,y,Max;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d %d %d",&N,&x,&y,&Max);
        a[0].h=y;
        a[0].xl=x;
        a[0].xr=x;
        for(int i=1; i<=N; i++) {
            scanf("%d %d %d",&a[i].xl,&a[i].xr,&a[i].h);
        }
        N++;
        sort(a+1,a+N,cmp);
        int cnt=0;
        for(int i=N-1;i>=0;i--){
            if(a[i].h==0) cnt++;
        }
        N=N-cnt;
        a[N].h=0;
        a[N].xl=-INF;
        a[N].xr=INF;
        memset(dp,-1,sizeof(dp));
        dp[0][0]=dp[0][1]=0;
        for(int i=0; i<=N; i++) {
            for(int j=0; j<i; j++) {
                if((dp[j][0]==-1&&dp[j][1]==-1)||a[j].h==a[i].h)continue;
                if((a[j].h-a[i].h)<=Max) {
                    if(a[i].xl<=a[j].xl&&a[i].xr>=a[j].xl) {
                        bool flag=false;
                        for(int k=j+1; k<i; k++)
                            if(a[k].xl<=a[j].xl&&a[k].xr>=a[j].xl&&(a[j].h-a[k].h)<=Max){
                                flag=true;
                                break;
                            }
                        if(flag==false) {
                            int tmp1=dp[j][0]+(a[i].xr-a[j].xl);//r
                            int tmp2=dp[j][0]+(a[j].xl-a[i].xl);//l
                            if(i==N) {tmp1=dp[j][0];tmp2=dp[j][0];}
                            if(dp[i][1]>tmp1||dp[i][1]==-1) {
                                dp[i][1]=tmp1;
                            }
                            if(dp[i][0]>tmp2||dp[i][0]==-1) {
                                dp[i][0]=tmp2;
                            }
                        }
                    }
                    if(a[i].xr>=a[j].xr&&a[i].xl<=a[j].xr) {
                        bool flag=false;
                        for(int k=j+1; k<i; k++)
                            if(a[j].xr>=a[k].xl&&a[j].xr<=a[k].xr&&(a[j].h-a[k].h)<=Max) {
                                flag=true;
                                break;
                            }
                        if(flag==false) {
                            int tmp1=dp[j][1]+(a[i].xr-a[j].xr);//r
                            int tmp2=dp[j][1]+(a[j].xr-a[i].xl);//l
                            if(i==N) {tmp1=dp[j][1];tmp2=dp[j][1];}
                            if(dp[i][0]>tmp2||dp[i][0]==-1) {
                                dp[i][0]=tmp2;
                            }
                            if(dp[i][1]>tmp1||dp[i][1]==-1) {
                                dp[i][1]=tmp1;
                            }
                        }
                    }
                }
            }
        }
        int ans1=dp[N][0];
        if(dp[N][0]==-1) ans1=INF;
        int ans2=dp[N][1];
        if(dp[N][1]==-1) ans2=INF;
        int ans=min(ans1,ans2);
        printf("%d\n",ans+y);

    }
    return 0;
}


然后就是记忆化DP：

 

又写了一个让我自己受冲击的代码，诶，明天再改

 

#include<stdio.h>
#include<algorithm>
#include<string.h>
#define INF 0x7f7f7f
using namespace std;
struct Node {
    int xl,xr,h;
}a[1009];
int N,Max,dp[1009];
bool cmp(Node aa,Node bb) {
    return aa.h>bb.h;
}
int Time(int t,bool left){
    if(dp[t]!=-1) return dp[t];
    if(t==N) {
        dp[N]=0;
        printf("++++++");
        return 0;
    }
    int x;
    if(left==true)
        x=a[t].xl;
    if(left==false)
        x=a[t].xr;
    int lenl=0;
    int lenr=0;
    for(int i=t+1;i<=N;i++){
        if((a[t].h-a[i].h)>Max) {
            dp[t]=INF;
            return INF;
        }
        if(a[t].xl<=x&&a[t].xr>=x&&a[t].h!=a[i].h){
            int ans1=Time(i,true);
            lenl=ans1+(x-a[i].xl);
            int ans2= Time(i,false);
            lenr=ans2+(a[i].xr-x);
            printf("%d %d %d %d %d %d %d %d %d\n",lenl,lenr,ans1,ans2,ans1+(x-a[i].xl),(a[i].xr-x)+ans2,x,(x-a[i].xl),(a[i].xr-x));
            dp[t]=min(lenl,lenr);
            return dp[t];
            //return (ans1+(x-a[i].xl))>((a[i].xr-x)+ans2)?(a[i].xr-x)+ans2:(ans1+(x-a[i].xl));
        }
    }
    //return lenl>lenr?lenr:lenl;
}
int main() {
    int t,x,y;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d %d %d",&N,&x,&y,&Max);
        a[0].h=y;
        a[0].xl=x;
        a[0].xr=x;
        for(int i=1; i<=N; i++) {
            scanf("%d %d %d",&a[i].xl,&a[i].xr,&a[i].h);
        }
        N++;
        sort(a,a+N,cmp);
        int cnt=0;
        for(int i=N-1;i>=0;i--){
            if(a[i].h==0) cnt++;
        }
        N=N-cnt;
        a[N].h=0;
        a[N].xl=-INF;
        a[N].xr=INF;
        memset(dp,-1,sizeof(dp));
        //dp[0]=0;
        Time(0,true);
        for(int i=0;i<=N;i++) printf("---%d\n",dp[i]);
        printf("%d\n",dp[0]+y);
    }
    return 0;
}

 

 

 

 

 

Twilightuse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
经典递归问题--帮助Jimmy POJ--1661
知识源于积累
04-16 1419
经典递归问题--帮助Jimmy--POJ 1661
Poj1155题解
09-29
Poj1155 题解 , 文档 , 资料
程序设计与算法（二）-Help Jimmy
weixin_45768308的博客
09-29 137
题目描述 “Help Jimmy” 是在下图所示的场景上完成的游戏： 场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。 设计一个程序，计算Jimmy到底地面时可能的最早时间。 输入 第一行是测试数据
Help Jimmy题解
qq_41641469的博客
05-29 170
这道题没有想出dp的解法，是在看了https://blog.csdn.net/qq_37605573/article/details/77366536的博客后才写出来的 #include <iostream> #include<string.h> #include<algorithm> #define INF 0x3f3f3f using namespace ...
帮助Jimmy
weixin_30823833的博客
07-26 112
//帮助Jimmy #include<stdio.h> #include<memory.h> #include<stdlib.h> #define MAX_N 1000 #define INFINITE 1000000 int t,n,x,y,max; struct Platform{ int Lx,Rx,h; }; Platform aPlatfo...
1661帮助 Jimmy
Ming-Kai
04-17 153
总时间限制: 1000ms 内存限制: 65536kB 描述 “Help Jimmy” 是在下图所示的场景上完成的游戏。 场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开...
poj1661.rar_c++帮助 Jimmy_help jimmy pu_帮助Jimmy java
09-19
poj题目，帮助jimmy，经典动态规划
POJ部分题解
12-21
POJ部分题解
poj acm 题解 算法
08-24
【标题】"poj acm 题解 算法"所指的是一份针对ACM（国际大学生程序设计竞赛）中POJ（Problemset Online Judge）平台上的题目进行解答的资源集合。ACM竞赛是全球范围内的一项编程竞赛，旨在提升大学生的算法设计和...
POJ 部分题解 解题报告
09-17
这些文件名揭示了若干个在编程竞赛中常见的算法和数据结构问题，主要集中在POJ（Programming Online Judge）和PKU（Peking University）的在线评测系统上。下面将逐一解析这些题目并介绍相关的编程知识点： 1. **...
百练1661 Help Jimmy
zizahn的博客
07-09 233
此题需要分成两种状态来规划：LeftMinTime[k]：从第k个平台的左端下落到地面的最短时间RightMinTime[k]：从第k个平台的右端下落到地面的最短时间如果平台k左端正下方有平台j，则必然会落到平台j上，从而需要求平台j的左右端下落到地面的最短时间。此题的wa点在于高度MAX，也就是如果两个平台之间的高度差大于MAX，则该条路是不可走的；还有就是如果落到平台边缘视为落到平台上，这样如...
poj 1661:帮助 Jimmy
abc15766228491的博客
03-26 570
总时间限制: 1000ms 内存限制: 65536kB 描述 “Help Jimmy” 是在下图所示的场景上完成的游戏。 场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速...
poj 1661:帮助 Jimmy动规
qq_38420683的博客
06-17 213
题目 总时间限制: 1000ms 内存限制: 65536kB 描述 “Help Jimmy” 是在下图所示的场景上完成的游戏。 场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边...
POJ ~ 1661 ~ Help Jimmy （DP + 细节）
张松超的博客
06-15 191
思路 首先我们这些木板信息存起来，再加上地面和起点，地面可以看做是一个[+∞，-∞]高度为0的木板，起点可以看做是[sx,sx]高度为sy的木板。对这些信息按照所在高度从大到小排序。 定义：dp[i][0]dp[i][0]dp[i][0] 表示到第iii块木板的左端花费的最小时间，dp[i][1]dp[i][1]dp[i][1] 表示到第iii块木板右端花费的最小时间。 状态转移方程看代码吧...
[POJ](1661)Help Jimmy ---- 动态规划
WangMeow --- ᶘ ᵒᴥᵒᶅ ฅ^•ﻌ•^ฅ
12-08 364
Description “Help Jimmy” 是在下图所示的场景上完成的游戏。 场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能
动态规划特训：帮助jimmy（POJ1661）递推解法
mavises的博客
08-05 258
上一篇文章中已经介绍了该题的递归解法。这里换一种思维使用递推的方式求解，其实方法差不多，设置两个dp数组按照上面的方式递推求解即可，稍微转换一下思路而已。这里直接给出代码。 #include&lt;stdio.h&gt; #include&lt;algorithm&gt; #include&lt;string.h&gt; #define inf 123123123 using namespac...
动态规划特训：帮助jimmy（POJ1661）递归解法
mavises的博客
08-05 264
该题为典型的动态规划题目，可以使用递推的思想求得一个存一个，或者利用动态规划进行求解，这里首先介绍递推的求解方案。在一块板子上往下走有两种方式，一种是往左边走，另一种是往右边走。我们设定mintime[1001][2]存储各种状态，min[x][0]代表处在板子左边向下走的最短时间，min[x][1]代表处在板子右边向下走的最短时间。以mintime[x][0]为例，计算该值即为计算到下一块板子（...
POJ 1661 SPFA过的。。。感谢各种牛贴出来的数据。。。
bingshen的专栏
03-27 1696
Help JimmyTime Limit: 1000MS Memory Limit: 10000KTotal Submissions: 6228 Accepted: 1939<br />Description"Help Jimmy" 是在下图所示的场景上完成的游戏。 <br /><br />场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 <br /><br />Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者
openmp(三)π值估计
qq_42304949的博客
03-18 832
公式 C(openmp)代码 #include <stdio.h> #include<stdlib.h> #include<omp.h> int main(int argc,char* argv[]) { double sum=0.0,factor; int i,n,thread_count; thread_count=st...
poj3635java题解
最新发布
06-02
POJ3635是一道经典的数学题，需要使用一些数学知识和算法进行解决。 题目描述： 给定四个正整数 a、b、p 和 k，求 a^b^p mod k 的值。 解题思路： 首先，我们可以将指数 b^p 写成二进制形式：b^p = c0 * 2^0 + ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值