动态规划:POJ(1661)Help Jimmy 动态规划

最新推荐文章于 2024-07-28 21:35:11 发布
最新推荐文章于 2024-07-28 21:35:11 发布
阅读量748 收藏 1
点赞数 1
分类专栏： Dynamic Programming 文章标签： algorithm c++ 动态规划 poj sortqsort
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m6830098/article/details/17406275
版权

        

        1 题目地址：猛戳我




        2.

Help Jimmy
Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 8223 Accepted: 2629

Description

"Help Jimmy" 是在下图所示的场景上完成的游戏。 

场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。 

Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。 

设计一个程序，计算Jimmy到底地面时可能的最早时间。 

Input

第一行是测试数据的组数t（0 <= t <= 20）。每组测试数据的第一行是四个整数N，X，Y，MAX，用空格分隔。N是平台的数目（不包括地面），X和Y是Jimmy开始下落的位置的横竖坐标，MAX是一次下落的最大高度。接下来的N行每行描述一个平台，包括三个整数，X1[i]，X2[i]和H[i]。H[i]表示平台的高度，X1[i]和X2[i]表示平台左右端点的横坐标。1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）。所有坐标的单位都是米。 

Jimmy的大小和平台的厚度均忽略不计。如果Jimmy恰好落在某个平台的边缘，被视为落在平台上。所有的平台均不重叠或相连。测试数据保证问题一定有解。 

Output

对输入的每组测试数据，输出一个整数，Jimmy到底地面时可能的最早时间。

Sample Input

1
3 8 17 20
0 10 8
0 10 13
4 14 3

Sample Output

23


        

  

        思路：找落到地面的最早时间，首先找到子问题的最优解。考虑当Jimmy落到一个板上的时候，他会有两种选择，向左走，向右走。我们如果知道当前的这个板左边到地面的最小值和右边到地面的最小值，则就可以求出解。每个板子从1开始进行编号，每个板子对应3个元素，左边坐标，右边坐标，以及高度坐标。每个板子的状态对应两个子问题，从板子左边到地面的最短时间和从板子右边到地面的最短时间。


        状态方程：


        设LeftMin（k）为k号板子的左边到地面的最小值，RightMin（k） 是k号板子的右边到地面的最小值，可以得出下列状态方程
        if（k号板子左端下面有板子，编号为m）{  //在m上我们有两种选择，从左边走，或者从右边走
              LeftMin（k） = h（k） - h（m） + Min（ LeftMin（m）+ 在m板子上走的距离，RightMin（m） + 在m号板子上走动的距离） 
        }
        else  //k号板子下面没有任何板子
       {
            if（k号板子高度大于max）
                  LeftMin（k) = 无穷大
           else
                  LeftMin（k）= k号板子的高度；
       }


        同理可以求得板子右边的状态方程，则一个板到最底边的最小值就可以求出来。

        

        


        代码：

Source Code

Problem: 1661		User: m68300981
Memory: 276K		Time: 16MS
Language: C++		Result: Accepted
Source Code
//
//  main.cpp
//  HelpJimmy
//
//  Created by mini on 12/18/13.
//  Copyright (c) 2013 mini. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;

#define MAX_N 1000
#define MAX_NODEFINE  1000000

struct Node{
    int rightPosition;
    int leftPosition;
    int height;
};

Node platformData[ MAX_N + 10 ];//记录每个板的信息
int rightMinTime[ MAX_N + 10 ] ;//第i个板右边到地面的时间
int leftMinTime[ MAX_N + 10 ];

int t, N, X, Y, Max;
//大到小排序
int MyCompare( const void*  x, const void*  y ){
    Node * p1, *p2;
    p1 = ( Node* )x;
    p2 = ( Node* )y;
    return p2 -> height - p1 ->height;
}

int MinTime( int num ,bool bLeft){
    int i;
    int y = platformData[ num ].height;
    int x;
    if( bLeft )
        x = platformData[ num ].leftPosition;
    else
        x = platformData[ num ].rightPosition;
    
    //找到第一个在num下面的板
    for(  i = num + 1; i <= N; i++ ){
        if( platformData[ i ].rightPosition >= x &&  platformData[ i ].leftPosition <= x )
            break;
    }
    //如果找到这个板
    if( i <= N ){
        if ( y - platformData[ i ].height > Max )
            return MAX_NODEFINE;
    }
    else{ // 没有找到板
        if( y > Max )
            return MAX_NODEFINE;
        else
            return  y;
        
    }
    int leftTime = y - platformData[ i ].height + x - platformData[ i ].leftPosition;
    int rightTime = y -platformData[ i ].height + platformData[ i ].rightPosition - x;
    
    if( rightMinTime[ i ] == -1 )
        rightMinTime[ i ] = MinTime( i, false );
    if( leftMinTime[ i ] == -1 )
        leftMinTime[ i ] = MinTime( i, true );
    leftTime += leftMinTime[ i ];
    rightTime += rightMinTime[ i ];
    if( leftTime < rightTime  )
        return leftTime;
    else
        return rightTime;
    return 0;
    
}
int main(int argc, const char * argv[])
{
    
    cin >> t;
    while( t ){
        memset( rightMinTime, -1, sizeof( rightMinTime ) );
        memset( leftMinTime, -1, sizeof( leftMinTime ) );
        cin>> N >> X >> Y >> Max;
        platformData[ 0 ].leftPosition = X;
        platformData[ 0 ].rightPosition = X;
        platformData[ 0 ].height = Y;
        for( int i = 1; i <= N; i++ )
            cin >> platformData[ i ].leftPosition >> platformData[ i ].rightPosition >> platformData[ i ].height;
        qsort( platformData, N + 1,sizeof( Node ), MyCompare);
        cout << MinTime( 0, true ) << endl;
        t--;
    }
    return 0;
    
   
}



        sort版本：

//
//  main.cpp
//  HelpJimmy
//
//  Created by mini on 12/18/13.
//  Copyright (c) 2013 mini. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;

#define MAX_N 1000
#define MAX_NODEFINE  1000000

struct Node{
    int rightPosition;
    int leftPosition;
    int height;
};

Node platformData[ MAX_N + 10 ];//记录每个板的信息
int rightMinTime[ MAX_N + 10 ] ;//第i个板右边到地面的时间
int leftMinTime[ MAX_N + 10 ];

int t, N, X, Y, Max;
//大到小排序
bool MyCompare( const Node&  x, const Node&  y ){
    return x.height > y.height;
}

int MinTime( int num ,bool bLeft){
    int i;
    int y = platformData[ num ].height;
    int x;
    if( bLeft )
        x = platformData[ num ].leftPosition;
    else
        x = platformData[ num ].rightPosition;
    
    //找到第一个在num下面的板
    for(  i = num + 1; i <= N; i++ ){
        if( platformData[ i ].rightPosition >= x &&  platformData[ i ].leftPosition <= x )
            break;
    }
    //如果找到这个板
    if( i <= N ){
        if ( y - platformData[ i ].height > Max )
            return MAX_NODEFINE;
    }
    else{ // 没有找到板
        if( y > Max )
            return MAX_NODEFINE;
        else
            return  y;
        
    }
    int leftTime = y - platformData[ i ].height + x - platformData[ i ].leftPosition;
    int rightTime = y -platformData[ i ].height + platformData[ i ].rightPosition - x;
    
    if( rightMinTime[ i ] == -1 )
        rightMinTime[ i ] = MinTime( i, false );
    if( leftMinTime[ i ] == -1 )
        leftMinTime[ i ] = MinTime( i, true );
    leftTime += leftMinTime[ i ];
    rightTime += rightMinTime[ i ];
    if( leftTime < rightTime  )
        return leftTime;
    else
        return rightTime;
    return 0;
    
}
int main(int argc, const char * argv[])
{
    
    cin >> t;
    while( t ){
        memset( rightMinTime, -1, sizeof( rightMinTime ) );
        memset( leftMinTime, -1, sizeof( leftMinTime ) );
        cin>> N >> X >> Y >> Max;
        platformData[ 0 ].leftPosition = X;
        platformData[ 0 ].rightPosition = X;
        platformData[ 0 ].height = Y;
        for( int i = 1; i <= N; i++ )
            cin >> platformData[ i ].leftPosition >> platformData[ i ].rightPosition >> platformData[ i ].height;
        sort(platformData, platformData + N + 1, MyCompare);
        //qsort( platformData, N + 1,sizeof( Node ), MyCompare);
        cout << MinTime( 0, true ) << endl;
        t--;
    }
    return 0;
}

        qsort和sort 的区别见： 猛戳我

     

        非递归版本，从下往上开始构造解空间

//
//  main.cpp
//  HelpJimmy
//
//  Created by mini on 12/18/13.
//  Copyright (c) 2013 mini. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;

#define MAX_N 1000
#define MAX_NODEFINE  1000000

struct Node{
    int r;//右边坐标
    int l;//左边坐标
    int height;//高度
};

Node p[ MAX_N + 10 ];//记录每个板的信息
int rightMinTime[ MAX_N + 10 ] ;//第i个板右边到地面的时间
int leftMinTime[ MAX_N + 10 ];

int t, N, X, Y, Max;
//大到小排序
bool MyCompare( const Node&  x, const Node&  y ){
    return x.height < y.height;
}
int MyCompareQsort( const void * x, const void * y){
    Node * p1 = ( Node * )x;
    Node * p2 = ( Node * )y;
    if( p1 -> height < p2 -> height  )
        return -1;
    else
        return 1;
}

int main(int argc, const char * argv[])
{
    
    cin >> t;
    while( t ){
        int i, j;
        memset( rightMinTime, -1, sizeof( rightMinTime ) );
        memset( leftMinTime, -1, sizeof( leftMinTime ) );
        cin>> N >> X >> Y >> Max;
        p[ 0 ].l = X;
        p[ 0 ].r = X;
        p[ 0 ].height = Y;
        for(  i = 1; i <= N; i++ )
            cin >> p[ i ].l >> p[ i ].r >> p[ i ].height;
        //qsort( p, N + 1,sizeof( Node ), MyCompareQsort );
        sort(p, p + N + 1, MyCompare);//从小到大排序排序p数组
        
        rightMinTime[ 0 ] = p[ 0 ].height;
        leftMinTime[ 0 ] = p[ 0 ].height;
        
        for (  i = 1; i <= N; i++ ) {  //从上往下构造解空间
            for (  j = i - 1; j >= 0; j-- ) {
                if ( p[ i ].l >= p[ j ].l && p[ i ].l <= p[ j ].r ) {
                    if ( p[ i ].height - p[ j ].height > Max )
                        leftMinTime[ i ] = MAX_NODEFINE;
                    else{
                        leftMinTime[ i ] = p[ i ].height - p[ j ].height +  min( p[ i ].l - p[ j ].l + leftMinTime[ j ], p[ j ].r - p[ i ].l + rightMinTime[ j ] );
                    }
                    break;
                }
            }
            if( j < 0 )//左边的跳跃点没有找到下面的板，
                leftMinTime[ i ] = p[ i ].height < Max ? p[ i ].height : MAX_NODEFINE;
            for (  j = i - 1; j >= 0; j-- ) {
                if ( p[ i ].r >= p[ j ].l && p[ i ].r <= p[ j ].r ) {
                    if ( p[ i ].height - p[ j ].height > Max )
                        rightMinTime[ i ] = MAX_NODEFINE;
                    else{
                        rightMinTime[ i ] = p[ i ].height - p[ j ].height +  min( p[ i ].r - p[ j ].l + leftMinTime[ j ], p[ j ].r - p[ i ].r + rightMinTime[ j ] );
                    }
                    break;
                }
            }
            if( j < 0 )
                rightMinTime[ i ] =p[ i ].height < Max ? p[ i ].height : MAX_NODEFINE;
        }
        
        cout << min( leftMinTime[ N ], rightMinTime[ N ] ) << endl;
        t--;
    }
    return 0;

}





慢慢来比较快
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通信系统：动态规划实践.pptx
12-19
通信系统中的动态规划实践 通信系统作为现代社会的基础设施， plays a crucial role in facilitating communication between individuals and organizations. However, with the increasing complexity of ...
poj1661.rar_c++帮助 Jimmy_help jimmy pu_帮助Jimmy java
09-19
【标题】"poj1661.rar" 是一个压缩包文件，主要包含有关C++和Java编程...总之，"poj1661.rar"提供的资料可以帮助我们深入理解和实践动态规划，无论你是C++还是Java的爱好者，都可以从中受益，提升编程竞赛的解题能力。
POJ动态规划题目全面总结
12-27
PKU Online Judge上面很全面的动态规划试题总结。动态规划是ACM考点中最重要的一大类算法之一，对于工作人员来说，动态规划也是实际开发中经常会遇到的算法。这是POJ上面很多DP题目的总结与深刻分析。利于算法学习，...
北大POJ初级-动态规划
07-31
北京大学的在线编程竞赛平台POJ（Problem Online Judge）为初学者提供了一系列的编程题目，其中“北大POJ初级-动态规划”是专门为学习和训练这个主题设立的板块。在这个部分，学员可以通过解题报告和已通过验证（AC...
算法实验（动态规划-12-16题）1
08-03
算法设计与动态规划 动态规划是一种常用的算法设计方法，它可以解决许多复杂的问题。动态规划的基本思想是将问题分解成多个小问题，然后通过解决这些小问题来解决整个问题。动态规划通常用于解决具有最优子结构的...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1222
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
规控面试常见问题
最新发布
每天进步一点点。
07-28 41
（1）A*在节点的扩张时，只会进行相邻节点的直线移动，没有考虑实际底盘的运动学模型（物理模型），而Hybrid A*在每次节点扩张的时候，会对下个位置进行离散状态空间的采样（比如 旋转角度、前进距离、前进/后退），选择动作之后就可以根据运动学模型计算下一个位置点的位姿，每次扩展的时候选择代价最小的节点进行扩展就能逐步到到目标点。// 8领域的坐标x y 和 g。A*受限于邻近栅格之间的连线，A*在搜索过程中扩展节点的方向被网格形状固定，一般为8邻接，导致路径呈波浪状，不平滑，发生抖动，冗余节点过多。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 670
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 279
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
Windows图形界面(GUI)-MFC-C/C++ - Dialog
0xCC说逆向
07-25 968
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 878
【C++初阶】string类
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 758
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
【C#/C++】C#调C++的接口，给C++传结构体数组
一个努力写代码的小菜鸟，目前主要从事图像算法，目标检测/分割，模型量化与部署的工作
07-24 308
C#软件创建了一个结构体数组用来存储图像的区域信息，分别是矩形框的左上像素的xy坐标和矩形框右下像素的xy坐标。需要传入给调用的C++函数的参数列表中，我们选择使用C#传入一个结构体数组指针的方式，C++的参数列表中也使用数组指针来接收这个变量。首先要保证C#和C++两边定义的结构体要完全一致。
如何在C\#中创建HTML表格
程序员-张师傅
07-24 327
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
C基础（学习）2024.7.24
qq_60450758的博客
07-24 1188
指针补充知识（指针修饰，二级指针，指针和数组，数组指针和指针数组）
STL 哈希 学习总结
gma999的博客
07-23 715
哈希是通过特定的算法，将任意长度的数据映射为固定长度的数据串中。该映射的结果就被称为哈希值，也可以称为散列值。例如在存储一个10000这个数据的时候，如果使用数组的话，则需要开辟对应大小空间内存，其他位置又不一定存储数据，所以这样就会造成数据的浪费。那么此时如果将这个数除以一个特定的数字，然后再将其存储到除数的结果下标中去，这样就避免了空间的浪费。哈希函数哈希值。
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 2409
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
嵌入式C++、MQTT、数据库、Grafana、机器学习（ Scikit-learn）：智能建筑大数据管理平台（代码示例）
嵌入式极客小张
07-25 1292
系统利用微控制器和传感器进行环境监测，通过MQTT等物联网协议传输数据。数据存储方面，采用InfluxDB、MongoDB和PostgreSQL等技术，确保对时序数据和结构化数据的高效管理。大数据处理使用Apache Hadoop和Spark，实时分析通过Apache Flink实现。数据分析与机器学习采用Python和深度学习框架（TensorFlow、PyTorch），而数据可视化则借助Grafana和Tableau等工具。云平台如AWS和Azure提供基础设施支持，提升系统的可扩展性和可靠性。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 259
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
递归与动态规划：ACM算法实例解析
本资源主要讲解了ACM算法中的递归与动态规划概念，以及它们在编程中的应用。首先，递归是一种通过将复杂问题分解为较小规模相同或相似子问题来求解的策略。它涉及到定义一个函数，使其调用自身来逐步缩小问题规模，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值