hdu 1074 Doing Homework(状压dp)

传送门：hdu 1074

题意：有n个作业，每个作业都有最迟上交时间和完成该作业所需的时间，若某作业超过最迟上交时间，则扣相应的分数，求上交所有的作业使得扣分最少，并输出作业的顺序，若扣分相同，则先交字典序较小的作业。（n<=15)

分析：每种作业都有已上交和未上交两种，状态，总共有2^15种状态，用二进制表示。

由于要记录扣分，当前时间和作业的顺序，所以定义一个结构体。

状态表示：dp[i].ans表示扣分

              dp[i].now表示当前时间

              dp[i].pre表示上一个状态

状态转移：(1)状态dp[sta]能上交作业j的条件是作业j还没上交，即sta&(1<<j)==0，此时状态变为dp[sta|(1<<j)]

              (2)若状态dp[x]和dp[y]都能到达状态dp[k],则应选择扣分最小的那条路径，即dp[k].ans=min(dp[k].ans,cost)，其中cost为上一个状态变为状态k时所需                     的花费，若扣分相等则转(3)

              (3)若扣分相等，则选字典序最小的路径

状态初始化：dp[i].ans=0,dp[i].now=0,dp[i].pre=-1

AC代码：

#include<stdio.h>
#include<string.h>
#define INF 0x3f3f3f3f
struct HomeWork{
    char s[105];
    int deadline,day;
}homework[20];
struct DP{
    int pre,ans,now;
}dp[2<<15];
int n;
int name[20];
void print()
{
    printf("%d
",dp[(1<<n)-1].ans);
    int i,k,num,j,cnt=0;;
    i=(1<<n)-1;
    while(dp[i].pre!=-1)
    {
        k=i^dp[i].pre;
        for(j=0;j<n;j++)
            if(k==(1<<j))
            {
                num=j;
                break;
            }
        name[cnt++]=num;
        i=dp[i].pre;
    }
    for(i=cnt-1;i>=0;i--)
        printf("%s
",homework[name[i]].s);
}
int min(int a,int b)
{
    return a<b?a:b;
}
int main()
{
    int t,i,j,k,tmp,cost,sta;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
            scanf("%s%d%d",homework[i].s,&homework[i].deadline,&homework[i].day);
        }
        for(i=0;i<(1<<n);i++)   //初始化
        {
            dp[i].ans=0;
            dp[i].now=0;
            dp[i].pre=-1;
        }
        for(sta=0;sta<(1<<n);sta++)    //枚举所有状态
        {
            for(j=0;j<n;j++)
            {
                i=sta&(1<<j);    //作业j还没做
                if(i==0)
                {
                    k=sta|(1<<j);   //新状态k
                    tmp=dp[sta].now+homework[j].day;
                    if(dp[k].now==0)   //状态k第一次出现
                    {
                        dp[k].now=tmp;
                        if(homework[j].deadline<tmp)
                            cost=tmp-homework[j].deadline;
                        else
                            cost=0;
                        dp[k].ans=dp[sta].ans+cost;
                        dp[k].pre=sta;
                    }
                    else
                    {
                        if(homework[j].deadline<tmp)   //状态sta转为k的花费
                            cost=tmp-homework[j].deadline;
                        else
                            cost=0;
                        cost+=dp[sta].ans;
                        if(cost==dp[k].ans)     //若扣分相等，则选择字典序最小的路径
                        {
                            dp[k].pre=min(dp[k].pre,sta);
                        }
                        else
                        {
                            if(cost<dp[k].ans)   //选择扣分最小的路径
                            {
                                dp[k].ans=cost;
                                dp[k].pre=sta;
                            }
                        }
                    }
                }
            }
        }
        print();
    }
    return 0;
}