C. Greetings! dp+枚举子集的子集 The North American Invitational Programming Contest 2016

题意：

给定n种信件，k种信封（每种假设无数个）；每种信件有一个w，h(宽和高)，还有数量 t，w和h不能倒置，

要用信封装信件得比信件大，，，大，，，==雾

如果k＜n，那必然有的小信件要用比较大的信封装，那样会浪费一些空间，问最小的浪费的空间是多大；

 

思路：

假算法：开始想的是贪心，n种信件，假设开始有n种信封，此时浪费的是0；然后每次合并两种信件，用同种信封，这时候会浪费一些，我们每次让这个浪费的数最小，然后直到合并成k种信件； 感觉挺对，后来测数据 AC47/50组，细想确实不对，只合并两堆的话这样是最优的，但是要是合并3堆的话，就不是最优了；

 

正解：dp[i][s] 表示前 i 种信封，用来装的信件集合为s的时候的最优解；

这里的s是信件的二进制表示，一共最多15种信件，

dp的常规思路，控制一部分最优解，另一部分找最优

我们先预处理出来所有集合，每个集合合并成一堆的最小浪费数c[s]，

在求解 dp[i][s] 时：我们考虑 t 是 s 的子集，k 是s 对于 t 的补集，dp[i][s] = min( dp[i][s],  dp[i-1][t] + c[k] ); 表示的是前 i-1种信封装 信件集合为 t 的最优解，加上 第 i 种信封装信件集合 k 的总体最优解；

 

 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 0x3f3f3f3f3f3f3f3f;

ll n, k;
ll c[(1<<15)] = {0};

struct node {
    ll w, h, t;
}a[20];

ll dp[20][(1<<16)] = {0};
// dp[i][s] 表示前i种信封，一共覆盖信件集合s的 最优解，即最小浪费
// dp[i][s] 由dp[i-1][t]和c[k]推得, t是s的子集，k是s对于t来说的补集

int main() {
    cin >> n >> k;
    for(int i = 0; i < n; ++i) {
        cin >> a[i].w >> a[i].h >> a[i].t;
    }
    if(k >= n) {
        printf("0");
        return 0;
    }
    int m = (1<<n);
    for(int i = 0; i < m; ++i) {             // 每个集合的最小浪费
        ll nw = 0, nh = 0, sum = 0, cnt = 0;
        for(int j = 0; j < n; ++j) {
            if(i & (1<<j)) {
                sum += (a[j].w * a[j].h * a[j].t);
                nw = max(nw, a[j].w);
                nh = max(nh, a[j].h);
                cnt += a[j].t;
            }
        }
        c[i] = (nw * nh * cnt - sum);
    }
    for(int i = 0; i <= k; ++i) {
        for(int s = 0; s < m; ++s) {
            dp[i][s] = INF;
        }
    }
    for(int s = 0; s < m; ++s) {
        dp[1][s] = c[s];
    }
    for(int i = 2; i <= k; ++i) {
        dp[i][0] = 0;
        for(int s = 0; s < m; ++s) {
            for(int t = s; t; t = (t-1)&s) {
                dp[i][s] = min(dp[i][s], dp[i-1][t] + c[s^t]);
            }
        }
    }
    printf("%lld\n", dp[k][m-1]);

    return 0;
}