(容量超大)or(容量及价值)超大背包问题 ( 折半枚举 || 改变 dp 意义 )

题意 :

以下两个问题的物品都只能取有且只有一次

① 给你 N 个物品，所有物品的价值总和不会超过 5000， 单个物品的价格就可达 10^10 ，背包容量为 B

② 给你 N (N ≤ 40 ) 个物品，物品的单个价值和重量都达到 10^15 问你在背包容量为 W

给出 ① 和 ② 问题条件下背包所能装出来的最大价值

分析 :

① 因为单个物品的价值实在太大，如果仍然按照普通 0/1 背包的 dp 定义方法数组是开不下的

但是发现价值的总和并不大，所以从价值这里下手，定义 dp[i][j] = 从 1 ~ i 个物品背包价值为 j 时的最小重量

dp 的状态转移方程效仿普通的 0/1 背包即可，但是是取最小 dp[i][j] = min(dp[i][j], dp[i-1][j-v[i]] + w[i])

同样可以使用 0/1 背包的空间优化将 dp 数组转化为一维的来减少空间复杂度

以下是 FZU 2214 的 AC 代码

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define LL long long
using namespace std;
;
const LL INF = 0x3f3f3f3f;
LL dp[maxn], w[], B;
];
int N, C;
 
int main(void)
{
    int nCase;
    scanf("%d", &nCase);
    while(nCase--){
        scanf("%d %lld", &N, &B);
        C = ;
        ; i<=N; i++)
            scanf("%lld %lld", &w[i], &v[i]),
            C += v[i]; /// C 累加的是所有物品的价值总和
 
        ; j<=C; j++)
            dp[j] = INF;/// 初始化 dp 数组应当赋予一个较大的数
        dp[] = ;
 
        ; i<=N; i++)
            for(int j=C; j>=v[i]; j--)
                dp[j] = min(dp[j], dp[j-v[i]]+w[i]);
 
        ; j--){
            if(dp[j] <= B){///从大到小遍历价值，第一个满足条件的 dp 数组值的下标便是答案
                printf("%d\n", j);
                break;
            }
        }
    }
    ;
}

② 因为价值和重量都太过于大，数组是完全开不下了，不能记录状态，所以考虑其他方法。

如果是去暴力，那么就是暴力枚举物品的组合，然后找到一个组合使得价值最大，复杂度为 O( 2^n )

这里 max( n ) == 40 ，所以时间复杂度还是大到无法接受，考虑是否能将问题规模降下来。

考虑折半枚举法，假设现 n == 40，折半思想是先把前 2^20 个物品的组合先枚举预处理出来 2^20 个 w、v

然后如果我们能对于这枚举出来的前 2^20 个和后面 2^20 个物品的某个组合结合然后找出最优的结果

最后从这 2^20 个最优结果中再取最优就是答案，问题就是如何对于预处理出来的前 2^20 个组合与后面结合产生最优

假设现在背包容量为 C ，在前 2^20 个物品组合中取出一个，价值为 vi 重量为 wi

那么如果我们能从后 2^20 个中找出一个组合使得其在满足重量 w' ≤ C - wi 的情况下价值最大

只要对于后 2^20 个的所有组合处理出其重量和价值，然后根据重量排序且根据价值去重

这样就能用二分查找来加快查找速度！

#include<bits/stdc++.h>
#define LL long long
using namespace std;
;
const LL INF = 0x3f3f3f3f;
pair<LL, LL> Pi[<<(maxn/)];
LL W[maxn], V[maxn], C;
int N;
 
int main(void)
{
    //freopen("in.txt", "r", stdin);
    while(~scanf("%d %lld", &N, &C)){
 
        ; i<N; i++)
            scanf("%lld %lld", &W[i], &V[i]);
 
        ;
        ; i<(<<n); i++){/// 利用二进制法枚举子集，集合个数应当为 2^n
            LL SumW, SumV;
            SumW = SumV = ;
            ; j<n; j++){
                ){
                    SumW += W[j];
                    SumV += V[j];
                }
            }
            Pi[i] = make_pair(SumW, SumV);/// 将每个组合的 重量&&价值 用 pair 存起来
        }
 
        sort(Pi, Pi+(<<n));/// 按照第一键值（重量）排序
        ;
        ; i<(<<n); i++)
            ].second < Pi[i].second)/// 这样的去重能找出在价值一样的情况下，保存最小的 w
                Pi[num++] = Pi[i];
 
        ; i<num; i++){
            printf("%d %lld %lld", i, Pi[i].first, Pi[i].second);
            puts("");
        }
 
        LL res = ;
        ; i<(<<(N-n)); i++){/// 枚举后半段的组合
            LL SumW, SumV;
            SumW = SumV = ;
            ; j<(N-n); j++){
                ){
                    SumW += W[n+j];
                    SumV += V[n+j];
                }
            }
            if(SumW <= C){
                ;
                pair<LL, LL> Temp = Pi[idx];
                res = max(res, SumV + Temp.second);
            }
        }
 
        printf("%lld\n", res);
    }
    ;
}