力扣天池赛-221021天池-04. 意外惊喜(分治优化dp)

题目

某电商平台举办了一个用户抽奖活动，奖池中共有若干个礼包，每个礼包中包含一些礼物。 present[i][j] 表示第 i 个礼包第 j 件礼（下标从 0 开始）物的价值。抽奖规则如下：

• 每个礼包中的礼物摆放是有顺序的，你必须从第 0 件礼物开始打开；
• 对于同一个礼包中的礼物，必须在打开该礼包的第 i 个礼物之后，才能打开第 i+1 个礼物；
• 每个礼物包中的礼物价值 非严格递增。

参加活动的用户总共可以打开礼物 limit 次，请返回用户能够获得的 最大 礼物价值总和。

提示：

• 1 <= present.length <= 2000
• 1 <= present[i].length <= 1000
• 1 <= present[i][j] <= present[i][j+1] <= 10^5
• 1 <= limit <= 1000

思路来源

灵茶山艾府（0x3f）的力扣讲解

题解

性质：最多只有一个礼包不全取

反证法，考虑同时有两个礼包不全取，

1 3 5 7 9

2 4 6 8 8

如一个礼包取了1、3、5，另一个礼包取了2、4、6，

则可以用调整法，如用6和7、5和8比较，决定一个礼包可不可以局部调整

由7不小于6，知7后面的数（这里为9）一定不小于6前面的数（这里为4），因为序列非严格递增

但是，这个性质并不能实际用于局部调整，因为可能24688的和比13579的和大，

所以，考虑枚举这个不全取的礼包，其他全取的礼包做01背包即可

当答案枚举到i(0<=i<n)的时候，其实需要[0,i-1]∪[i+1,n-1]的01背包的答案

1.考虑用倍增优化背包？（预处理以i为起点，长度为1、2、4…的背包的答案）

不太行，实际两个背包合并的复杂度是O(1000*1000)的，不如背包内放一个物品的复杂度O(1000)

2.考虑用背包撤销？（把物品放进去，撤销的时候做一遍逆操作）

不太行，max信息无法撤销，sum这种各个贡献独立的才可撤销

3.考虑用分治优化背包，设当前区间[l,r]，

先用tmp数组把当前dp暂存下来，把[mid+1,r]的01背包算进去后，再递归进[l,mid]

用tmp数组将dp恢复，把[l,mid]的01背包算进去后，再递归进[mid+1,r]

在进入一个区间之前，这个区间的补集已经在之前的递归中算过了，

在递归每一层的区间时，算区间的另一半背包的答案，

当l=r的时候，即枚举当前背包是那个不全取的背包，更新答案

代码

class Solution {
public:
    int ans,up,a[2005],sz[2005],dp[1005];
    void dfs(vector<vector<int>>& p,int l,int r){
        if(l==r){
            ans=max(ans,dp[up]);
            int cur=0;
            for(int i=1;i<=min(up,sz[l]);++i){
                cur+=p[l][i-1];
                ans=max(ans,dp[up-i]+cur);
            }
            return;
        }
        int mid=(l+r)/2;
        vector<int>tmp(1005,0);
        for(int i=0;i<=up;++i){
            tmp[i]=dp[i];
        }
        for(int i=mid+1;i<=r;++i){
            for(int j=up;j>=sz[i];--j){
                dp[j]=max(dp[j],dp[j-sz[i]]+a[i]);
            }
        }
        dfs(p,l,mid);
        for(int i=0;i<=up;++i){
            dp[i]=tmp[i];
        }
        for(int i=l;i<=mid;++i){
            for(int j=up;j>=sz[i];--j){
                dp[j]=max(dp[j],dp[j-sz[i]]+a[i]);
            }
        }
        dfs(p,mid+1,r);
    }
    int brilliantSurprise(vector<vector<int>>& p, int lim) {
        ans=0;
        up=lim;
        int n=p.size();
        for(int i=0;i<n;++i){
            a[i]=accumulate(p[i].begin(),p[i].end(),0);
            sz[i]=p[i].size();
        }
        memset(dp,0,sizeof dp);
        dfs(p,0,n-1);
        return ans;
    }
};