hdu1074 Doing Homework

这题比较有意思，暴力搜索必然tle，可以用状态压缩dp解决。

我们先不考虑完成所有作业的扣分，而考虑其一个子集的情况。

假设我们得到了完成某子集S对应的作业最少扣分，我们试着向该子集中增加一个元素a，那么我们将得到一个新的集合S1。

从而f(S1) = min(g(S^')),  S^'⊂S, 且#(S^') = #(S) - 1。

 其中g函数仅依赖于集合S^'与元素e = (S - S')。

如果我们能够在处理S之前将其所有真子集都处理完毕，那么S可以直接由原状态导出。

于是当更新到S为全集的时候，答案也就得到了。

考虑用二进制表示状态，二进制数某一位为1或0代表同位次的元素属于（不属于）该集合。

所有子集的数值大小都比原集合小。

将二进制数从小到大扫描一遍即可。

这就是所谓的状态压缩dp。

复杂度O(n * 2^n)。

acm.hdu.edu.cn/showproblem.php?pid=1074

 

 

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
typedef __int64 LL;

const int inf = 0x3f3f3f3f;
const int maxn = 100 + 10;
const int maxm = 1 << 16;

char s[20][maxn];
int n, high;
struct Node{
    int t, dl;
}node[maxn];
int dp[maxm];
int tc[maxm], pre[maxm], ans[20];

void print(){
    printf("%d
", dp[high]);
    int p = high, k = 0;
    while(p){
        ans[k++] = pre[p];
        p -= 1 << pre[p];
    }
    for(int i = k - 1; i >= 0; i--) puts(s[ans[i]]);
}

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d", &n);
        for(int i = 0; i < n; i++){
            scanf("%s%d%d", s[i], &node[i].dl, &node[i].t);
        }
        high = (1 << n) - 1;
        memset(dp, inf, sizeof dp);
        dp[0] = 0;
        for(int i = 1; i <= high; i++){
            for(int j = n - 1; j >= 0; j--){
                int tem = 1 << j;
                //update the current state by enumerating the new element
                if(tem & i){
                    //i is the current state while (i - tem) is the previous state
                    int p = max(0, node[j].t + tc[i - tem] - node[j].dl);
                    if(p + dp[i - tem] < dp[i]){
                        dp[i] = p + dp[i - tem];
                        tc[i] = node[j].t + tc[i - tem];
                        pre[i] = j;
                    }
                }
            }
        }
        print();
    }
    return 0;
}