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 =  + ;
 const int maxm =  << ;

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

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

 int main(){
     int T;
     scanf("%d", &T);
     while(T--){
         scanf("%d", &n);
         for(int i = ; i < n; i++){
             scanf("%s%d%d", s[i], &node[i].dl, &node[i].t);
         }
         high = ( << n) - ;
         memset(dp, inf, sizeof dp);
         dp[] = ;
         for(int i = ; i <= high; i++){
             for(int j = n - ; j >= ; j--){
                 int tem =  << 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(, 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 ;
 }