hdu - 4314 - Save the dwarfs - dp

最新推荐文章于 2020-03-30 21:25:18 发布

Julyana_Lin

最新推荐文章于 2020-03-30 21:25:18 发布

阅读量738

点赞数

CC 4.0 BY-SA版权

分类专栏： 2012 Multi-University 02 dp 文章标签： struct

本文链接：https://blog.youkuaiyun.com/Julyana_Lin/article/details/8084484

dp 同时被 2 个专栏收录

19 篇文章

订阅专栏

2012 Multi-University 02

10 篇文章

订阅专栏

本文介绍了一道复杂的动态规划题目——逃人问题。通过将人员按肩高加手高排序，并采用动态规划方法，计算出最多能有多少人逃离。核心在于理解状态转移方程，确保每次转移都能得到最优解。

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

又是一道很纠结的dp，我已经战亡。不过这题好点，看还是看得懂的，理解着理解着，感觉半懂还是有的。

题意：http://acm.hdu.edu.cn/showproblem.php?pid=4314

每人有个肩高和手高。n个人迭罗汉，最上边的那个人要伸出双手能够到h就行。问能逃出多少人。

在此不得不多说一句，多校的解题报告真*******，想把写解题报告的人暴打一遍。

较难的动态规划题。一个重要的观察是，如果某些矮人可以逃脱，那么我们总可以把他们的逃脱顺序按照Ai+Bi递增排序（即Ai+Bi最小的先逃脱），得到的结果不会更坏。于是可以先按Ai+Bi排序处理即可。用dp[i][j]表示最后i个人能逃出j个时，需要之前井中剩下的人的最小A高度之和。有如下转移方程dp[i][j] = min(dp[i-1][j] - s[i-1].a, max(dp[i-1][j-1], H - sumA[i-1] - s[i-1].b ))。最后找到最大的j满足dp[n][j]<=0即为所求。

dp[i][j]代表由大到小排序后，前i人中能逃脱j人需要之前的人留在井中的高度和。（我感觉表示的是除了人之外需要的高度，这样最后的判断也就顺理成章了）
每一次必然是身高和臂长和短的人先逃出去，dp[i][j]只可能由两种情况得来：
dp[i-1][j]：代表i位置的人没出去，所以所需的高度就是dp[i-1][j] - a[i]。
dp[i-1][j-1]：代表i位置的人出去了，所需高度有两种情况：
1. i的身高和臂长之和足够大，利用之前所需高度就可以逃脱，这是所需高度是dp[i-1][j-1]。
2. i的身高和臂长之和不够大，因为每一次必然是短的人先出去，而排序后i的长度必然最短，所以需要的高度就是后i-1个人帮助i逃脱，所需高度是H - sumA[i] - b[i]。
这两种情况要取最大值。

综上所述，最终的递推公式就是：
dp[i][j] = min(dp[i-1][j] - a[i], max(dp[i-1][j-1], H - sumA[i] - b[i]);

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 2005;
const int INF = 1000000000;

struct Node
{
    int a, b;
    bool operator < (const Node &node) const
    {
        return (a + b) > (node.a + node.b);
    }
}node[MAXN];
int n, h;
int dp[MAXN][MAXN];
int sumA[MAXN];

inline int min(const int &x, const int &y)
{
    return x < y ? x : y;
}

inline int max(const int &x, const int &y)
{
    return x > y ? x : y;
}

int main()
{
    while(~scanf("%d", &n))
    {
        for(int i=1;i<=n;++i)
        {
            scanf("%d%d", &node[i].a, &node[i].b);
        }
        scanf("%d", &h);
        sort(node + 1, node + n + 1);
        sumA[1] = node[1].a;
        for(int i=2;i<=n;++i)
        {
            sumA[i] = sumA[i-1] + node[i].a;
        }
        memset(dp, 0, sizeof(dp));
        for(int i=0;i<=n;++i)
        {
            for(int j=i+1;j<=n;++j)
            {
                dp[i][j] = INF;
            }
        }
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=i;++j)
            {
                dp[i][j] = min(dp[i-1][j] - node[i].a, max(dp[i-1][j-1], h - sumA[i] - node[i].b));
            }
        }
        for(int i=n;i>=0;--i)
        {
            if(dp[n][i] <= 0)
            {
                printf("%d\n", i);
                break;
            }
        }
    }
    return 0;
}