HDU1074(KB12-D 状态压缩dp)

Doing Homework

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8756    Accepted Submission(s): 4065

Problem Description

Ignatius has just come back school from the 30th ACM/ICPC. Now he has a lot of homework to do. Every teacher gives him a deadline of handing in the homework. If Ignatius hands in the homework after the deadline, the teacher will reduce his score of the final test, 1 day for 1 point. And as you know, doing homework always takes a long time. So Ignatius wants you to help him to arrange the order of doing homework to minimize the reduced score.

 

Input

The input contains several test cases. The first line of the input is a single integer T which is the number of test cases. T test cases follow.
Each test case start with a positive integer N(1<=N<=15) which indicate the number of homework. Then N lines follow. Each line contains a string S(the subject's name, each string will at most has 100 characters) and two integers D(the deadline of the subject), C(how many days will it take Ignatius to finish this subject's homework). 

Note: All the subject names are given in the alphabet increasing order. So you may process the problem much easier.

 

Output

For each test case, you should output the smallest total reduced score, then give out the order of the subjects, one subject in a line. If there are more than one orders, you should output the alphabet smallest one.

 

Sample Input

2 3 Computer 3 3 English 20 1 Math 3 2 3 Computer 3 3 English 6 3 Math 6 3

 

Sample Output

2 Computer Math English 3 Computer English Math

Hint

In the second test case, both Computer->English->Math and Computer->Math->English leads to reduce 3 points, but the word "English" appears earlier than the word "Math", so we choose the first order. That is so-called alphabet order.

 

//2017-03-28
//状态压缩dp，sta的二进制所在位为1表示对应的作业已经处理，0表示未处理。sta低位对应为字典序小的课程。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>

using namespace std;

const int N = (1<<15)+10;
const int inf = 0x3f3f3f3f;
int pre[N];//pre[i]表示状态i由前一个状态转移来时放入的作业编号
int dp[N];//dp[i]表示达到状态i所扣的最少的分
int tm[N];//tm[i]表示到达状态i花费的最少时间
int order[20];//用于保存最后输出的课程序列
int n;
struct node
{
    string name;
    int d, c;
}work[20];

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i = 0; i < n; i++)
              cin>>work[i].name>>work[i].d>>work[i].c;
        for(int sta = 1; sta < (1<<n); sta++)
        {
            dp[sta] = inf;
            for(int j = n-1; j >= 0; j--)//为使序列倒序输出，从字典序大的作业开始枚举
            {
                int fmsta = (1<<j);//表示当前状态sta可以由sta-fmsta状态转移而来。
                if(!(fmsta&sta))continue;//表示该sta-fmsta不能转移到sta，继续
                int score = tm[sta-fmsta] - (work[j].d - work[j].c);//tm[sta-fmsta]表示转移前状态所花费的最小时间，(work[j].d - work[j].c)表示work[j]能开始的最晚时间。
                if(score < 0)score = 0;//若转移前时间比最晚开始时间早，所需要扣的分为0
                if(dp[sta] > dp[sta-fmsta]+score){
                    dp[sta] = dp[sta-fmsta]+score;
                    tm[sta] = tm[sta-fmsta] + work[j].c;
                    pre[sta] = j;
                }
            }
        }
        cout<<dp[(1<<n)-1]<<endl;
        int cnt = 0, pos = (1<<n)-1;
        stack<int> s;
        while(pos)
        {
            s.push(pre[pos]);
            pos = pos-(1<<pre[pos]);
        }
        while(!s.empty())
        {
            cout<<work[s.top()].name<<endl;
            s.pop();
        }
    }

    return 0;
}