UVA10154 01背包

最新推荐文章于 2018-12-06 20:21:41 发布

big up

最新推荐文章于 2018-12-06 20:21:41 发布

阅读量419

点赞数

CC 4.0 BY-SA版权

分类专栏： DP 01背包

本文链接：https://blog.youkuaiyun.com/vv494049661/article/details/50775694

DP 同时被 2 个专栏收录

83 篇文章

订阅专栏

01背包

4 篇文章

订阅专栏

本文介绍了一个有趣的乌龟堆叠问题及其动态规划解决方案。通过将乌龟按其可承受重量排序，并使用二维数组dp来记录每一步的最优解，最终找到能够堆叠的乌龟数量的最大值。

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

题目大意：
给出乌龟的体重和可以承受的重量。
求可以叠起来的最高的乌龟是多少。

思路：
dp[i][j]表示的是前i只到第j层的最轻的重量。
首先，要按照乌龟的承受重量从小到大排序。
只要,s[i] - w[i] >= dp[i - 1][j - 1] && dp[i -1][ k - 1] !=INF （条件： s[i] - w[i] >= dp[i - 1][j - 1]那么就可以承受得了j - 1层的乌龟的重量，dp[i - 1][k - 1]是保证有值）那么
dp[i][j] = min(dp[i- 1][j],dp[i - 1][k - 1] + w[i]);
相当于01背包，第j层不要乌龟i和要乌龟i。
代码：

#include <iostream>
using namespace std;
#include <stdio.h>
#include <cstring>
#include <algorithm>

const int INF = 0x7ffffff;
int dp[5610][5610];
struct node {
    int w,s;
    friend bool operator < (const node & a,const node &b) {
        return a.s < b.s;
    }
}n[5610];
int main() {

    int i = 1;
    while(scanf("%d %d",&n[i].w,&n[i].s) != EOF) {
    //  printf("%d %d\n",w[i],strength[i]);
        i++;
    }
    //printf("%d\n",i);
    sort(n + 1,n + i);
     for(int j = 0; j <= i ; j++) {
         dp[j][0] = 0;
         for(int k = 1; k <= i; k++)
             dp[j][k] = INF;
     }
     for(int j = 1; j <= i; j++) {
         for(int k = 1; k <= j; k++) {
             dp[j][k] = dp[j - 1][k];
             if(n[j].s - n[j].w >= dp[j - 1][k - 1] && dp[j - 1][k - 1]!=INF)
                 dp[j][k] = min(dp[j][k],dp[j - 1][k - 1] + n[j].w);
            // printf("%d\n",dp[j][k]);
         }

     }
         for(int j = i - 1; j >= 0; j--) {
    //       printf("%d\n",dp[i][j]);
             if(dp[i - 1][j] != INF) {
                    printf("%d\n",j);
                    break;
             }
         }

    return 0;
}