4149：课程大作业，考点：动态规划、记录路径、字典序小的优先输出

原题：http://bailian.openjudge.cn/practice/4149/

描述

小明是北京大学信息科学技术学院三年级本科生。他喜欢参加各式各样的校园社团。这个学期就要结束了，每个课程大作业的截止时间也快到了，可是小明还没有开始做。每一门课程都有一个课程大作业，每个课程大作业都有截止时间。如果提交时间超过截止时间X天，那么他将会被扣掉X分。对于每个大作业，小明要花费一天或者若干天来完成。他不能同时做多个大作业，只有他完成了当前的项目，才可以开始一个新的项目。小明希望你可以帮助他规划出一个最好的办法(完成大作业的顺序)来减少扣分。

输入

输入包含若干测试样例。
输入的第一行是一个正整数T，代表测试样例数目。
对于每组测试样例，第一行为正整数N（1 <= N <= 15）代表课程数目。
接下来N行，每行包含一个字符串S（不多于50个字符）代表课程名称和两个整数D（代表大作业截止时间）和C（完成该大作业需要的时间）。
注意所有的课程在输入中出现的顺序按照字典序排列。

输出

对于每组测试样例，请输出最小的扣分以及相应的课程完成的顺序。
如果最优方案有多个，请输出字典序靠前的方案。

样例输入

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

样例输出

2 
Computer 
Math 
English 
3 
Computer 
English 
Math

解法

思路：动态规划

dp[s]：表示已经完成的作业集合为s时达到的最少扣分

初始条件：dp[0]=0

状态转移：dp[s] = min{ dp[s-j] + dominus(j) } 

由于输出和计算的需要，要保存以下几个变量

1. 达到最小时的j
2. 此时的天数（要计算扣分）
3. 前一个状态（因为要输出路径）
4. 最小的得分

关键：字典序小的优先输出，所以当相同的时候要比较此时路径的字典序。

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#define INF 1<<30
using namespace std;
class project {
public:
    string name;
    int ddl;
    int need;
    friend istream& operator>>(istream&in, project&A) {
        in >> A.name >> A.ddl >> A.need;
        return in;
    }
}projects[16];
class Node {
public:
    int pre;
    int minscore;
    int last;
    int finishday;
}dp[(1<<16)+10];//dp[s]表示已经完成的作业集合为s时所能达到的最少扣分
int dominus(int nowday, int j) {
    if (nowday + projects[j].need <= projects[j].ddl)
        return 0;
    else
        return nowday + projects[j].need - projects[j].ddl;
}
vector<string> getpath(int k) {
    vector<string>result;
    while (dp[k].pre != 0) {
        result.push_back(projects[dp[k].last].name);
        k = dp[k].pre;
    }
    result.push_back(projects[dp[k].last].name);
    reverse(result.begin(), result.end());
    return result;
}
bool operator < (const vector<string>&A, const vector<string>&B) {
    for (int i = 0, j = 0; i < A.size() && j < B.size(); i++, j++) {
        if (A[i] < B[j])
            return true;
        else if (A[i] > B[j])
            return false;
    }
    return false;
}
int main()
{
    int T;
    cin >> T;
    while (T--) {
        memset(dp, 0, sizeof(dp));
        //memset(projects, 0, sizeof(projects));
        int N;
        cin >> N;
        for (int i = 0; i < N; i++)
            cin >> projects[i];
        for (int s = 1; s < (1 << N); s++) {
            dp[s].minscore = INF;
            for (int j = 0; j < N; j++) {
                if ((s >> j) & 1) {
                    int s_j = s - (1 << j);
                    int nowscore = dp[s_j].minscore + dominus(dp[s_j].finishday, j);
                    if ( nowscore< dp[s].minscore) {
                        dp[s].minscore = nowscore;
                        dp[s].pre = s_j;
                        dp[s].last = j;
                        dp[s].finishday = dp[s_j].finishday + projects[j].need;
                    }
                    else if (nowscore == dp[s].minscore) {
                        vector<string>a = getpath(s_j);
                        vector<string>b = getpath(dp[s].pre);
                        if (a < b) {
                            dp[s].minscore = nowscore;
                            dp[s].pre = s_j;
                            dp[s].last = j;
                            dp[s].finishday = dp[s_j].finishday + projects[j].need;
                        }
                    }
                }
            }
        }
        cout << dp[(1 << N) - 1].minscore << endl;
        vector<string>paths = getpath((1 << N) - 1);
        for (int i = 0; i < paths.size(); i++)
            cout << paths[i] << endl;
    }
}