poj 1661 Help Jimmy（DP：记忆化搜索）

最新推荐文章于 2021-02-13 22:19:56 发布

原创最新推荐文章于 2021-02-13 22:19:56 发布 · 462 阅读

1 ·

CC 4.0 BY-SA版权

动态规划专栏收录该内容

67 篇文章

订阅专栏

本文介绍了一种使用记忆化搜索解决复杂平台跳跃问题的方法。通过递归计算从每个平台跳到下一个平台所需的最短时间，并利用记忆化技术避免重复计算，有效解决了问题。代码实现了从初始位置出发，找到抵达底部平台的最短路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

遇到这一类变量要求比较多的题目完全不知道该从哪里下手啊

感觉这个题用记忆化搜索写才方便

我们每次搜索上一个平台，递归计算出从左侧下来和右侧下来用时

并取其较小者

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 1010
#define INF 100000000
using namespace std;

int leftmin[MAXN], rightmin[MAXN];
int n, X, Y, MAX;

struct Platform {
    int l, r, h;
}p[MAXN];

bool cmp(Platform a, Platform b) {
    return a.h > b.h;
}

int mintime(int cur, int flag) { //用flag标志向左或向右
    int x, h, i, ltime, rtime;
    h = p[cur].h;
    if(flag) {
        x = p[cur].l;
    } else x = p[cur].r;

    for(i=cur+1; i<=n; ++i) {
        if(p[i].l<=x && p[i].r>=x) //可以从当前位置跳到第i个平台上
            break;
    }
    if(i <= n) {
        if(h-p[i].h > MAX)
            return INF;
    } else {//到达底部平台
        if(h > MAX)
            return INF;
        return h;
    }

    ltime = rtime = h-p[i].h;
    ltime += x-p[i].l;
    rtime += p[i].r-x;

    if(leftmin[i] == -1) //记忆化搜索
        leftmin[i] = mintime(i, 1);
    if(rightmin[i] == -1)
        rightmin[i] = mintime(i, 0);
    ltime += leftmin[i];
    rtime += rightmin[i];
    return ltime > rtime ? rtime : ltime;
}

int main(void) {
    int T;
    scanf("%d", &T);
    while(T--) {

        memset(leftmin, -1, sizeof(leftmin));
        memset(rightmin, -1, sizeof(rightmin));

        scanf("%d%d%d%d", &n, &X, &Y, &MAX);
        p[0].l = X;
        p[0].r = X;
        p[0].h = Y;

        for(int i=1; i<=n; ++i) {
            scanf("%d%d%d", &p[i].l, &p[i].r, &p[i].h);
        }

        sort(p, p+n+1, cmp);

        printf("%d\n", mintime(0, 1));
    }

    return 0;
}