状态压缩DP题目小节（三）

把最近做的一些状态压缩DP整理一下。DP苦手，从简单的开始。

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1297

zoj 2297 

题目大意是和n人车轮战，你可以选择对战顺序，和每个人对战会消耗ci的体力，若此时体力小于0（注意是小于不是不大于），则失败，打过一个人后会恢复ri的体力。问你有没有一种顺序使得你能够打完最后一个人。

 

很明显的状态压缩DP，开始因为小于0的问题WA一次（不科学呀，谁看过那个游戏HP减到0还活蹦乱跳的！），设dp[flag]为打过的人的状态为flag时所剩HP的最大值，则

dp[flag]=max(dp[flag']-c[i]+r[i])其中dp[flag']>=c[i]且flag'=flag^(1<<i)，因为最后一个人是固定的，所以我们最后比较dp[flag]（这里flag表示除最后一个人外其让人都已打过的状态 ）和c[n]即可，代码如下：

 

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
using namespace std;
int dp[1<<20];
int c[21],r[21];
int max(int a,int b)
{
    return a>b?a:b;
}
int min(int a,int b)
{
    return a<b?a:b;
}
int n;
int dfs(int flag)
{
    if(dp[flag]!=-1)
    return dp[flag];
    int i;
    int ans=0;
    for(i=1;i<n;i++)
    {
        if(flag&(1<<(i-1)))
        {
            int tmp=dfs(flag^(1<<(i-1)));
            if(tmp>=c[i])
            {
                ans=max(ans,min(100,tmp-c[i]+r[i]));
            }
        }
    }
    return dp[flag]=ans;
}
int main()
{
    //freopen("dd.txt","r",stdin);
    while(scanf("%d",&n)!=EOF)
    {
        int i;
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&c[i],&r[i]);
        }
        scanf("%d",&c[n]);
        int limit=(1<<(n-1))-1;
        for(i=0;i<=limit;i++)
        dp[i]=-1;
        dp[0]=100;
        if(dfs(limit)>=c[n])
        printf("clear!!!\n");
        else
        printf("try again\n");
    }
    return 0;
}

 

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4345
zoj 3502

也是很基础的状态压缩DP吧，这里只要清楚期望值就是把每个题目的正确率相加即可。最大期望值很好求。但是我WA了7次，为什么呢？因为还要把题目的顺序求出来，并且还要是万恶的字典序最小。。。这里设dp[flag]表示此状态下过的题的最大期望值（0表示这道题还没看，1表示这道题已做，不管是否正确）。求所有题都做过后的最大期望值即可，dp[flag]很好求，这里不再详述，求具体顺序稍微麻烦点，我暴力的，设way[flag]表示此状态下达到最大期望值时的最小字典序，然后暴力更新，今天这道题算是整死我了。。。。代码如下：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
using namespace std;
int bo[10][10];
char way[1<<10][10];
int dp[1<<10];
int n;
int dfs(int flag)
{
    if(dp[flag]!=-1)
    return dp[flag];
    int i,j,k,num=0;
    int a[10];
    for(i=0;i<n;i++)
    {
        if(flag&(1<<i))
        {
            a[num++]=i;
        }
    }
    //printf("%d\n",num);
    int ans=-1,po;
    for(i=0;i<num;i++)
    {
        int tmp=0;
        int now=a[i];
        for(j=0;j<num;j++)
        {
            if(bo[a[j]][now]>tmp)
            {
                tmp=bo[a[j]][now];
            }
        }
        if(tmp+dfs(flag^(1<<now))>ans)
        {
            ans=tmp+dfs(flag^(1<<now));
            strcpy(way[flag],way[flag^(1<<now)]);
            int len=strlen(way[flag]);
            way[flag][len]=now+'A';
            way[flag][len+1]='\0';
            po=now;
        }
        else if(tmp+dfs(flag^(1<<now))==ans)
        {
            if(strcmp(way[flag^(1<<now)],way[flag^(1<<po)])<0)
            {
                strcpy(way[flag],way[flag^(1<<now)]);
                int len=strlen(way[flag]);
                way[flag][len]=now+'A';
                way[flag][len+1]='\0';
                po=now;
            }
        }
    }
    return dp[flag]=ans;
}
int aa[10];
int main()
{
    //freopen("dd.txt","r",stdin);
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
      int i,j;
      scanf("%d",&n);
      for(i=0;i<n;i++)
      {
          for(j=0;j<n;j++)
          {
              scanf("%d",&bo[i][j]);
          }
      }
      int limit=(1<<n)-1;
      memset(dp,-1,sizeof(dp));
      memset(way,'\0',sizeof(way));
      dp[0]=0;
      int ans=dfs(limit);
      printf("%.2f\n",(double)ans/100);
      printf("%s\n",way[limit]);
    }
    return 0;
}

 

http://poj.org/problem?id=2923

poj 2923

题目大意：一个人要搬家，有两辆车，两辆车的载重量分别为c1,c2，现在给你每一件家具的重量c[i]，问最少来回几次可以把这些家具搬完。

我们设dp[0][flag]表示用第一辆车搬状态为flag的家具最少要来会多少次(flag中1表示搬这件家具，0表示不搬)，对于第二辆车我们可以类似处理，设w[0][flag]表示第一辆车搬完了状态为flag的家具后，其最大剩余载重量。那么状态转移就变得非常明显。我们对于每一个状态，枚举本次要搬的家具，设为i，（前提是当前状态包含i），则在搬第i件家具前的状态为flag'=(flag^(1<<i))，若w[0][flag']>=c[i]，则dp[flag]=dp[flag']，否则dp[flag]=dp[flag']+1，我们取dp[flag]的最小值，同时对于最小值相同的情况，我们要保证w[0][flag]最大。求完之后，我们一次枚举状态flag计算dp[0][flag]和dp[1][~flag]（这里的~flag指的是flag取反）的较大值，然后去这些值中最小的一个即可。代码如下：

#include <string.h>
#include <algorithm>
#include <stdio.h>
#define inf 2100000000
using namespace std;
int dp[2][1<<10],left[2][1<<10],c[2],v[11];
int n;
int min(int a,int b)
{
    return a<b?a:b;
}
int max(int a,int b)
{
    return a>b?a:b;
}
int dfs(int flag,int t)
{
    //printf("f");
    if(dp[t][flag]!=-1)
    return dp[t][flag];
    if(flag==0)
    {
        left[t][flag]=c[t];
        return dp[t][flag]=1;
    }
    int i;
    int ans=inf,ll=0,num,le,tans,tleft;
    for(i=1;i<=n;i++)
    {
        if(flag&(1<<(i-1)))
        {
            int tmp=flag^(1<<(i-1));
            num=dfs(tmp,t),le=left[t][tmp];
            if(le<v[i])
            {
                if(v[i]>c[t])
                {
                    left[t][flag]=0;
                    return dp[t][flag]=inf;
                }
                else
                {
                    tleft=c[t]-v[i];
                    tans=num+1;
                }
            }
            else
            {
                tleft=le-v[i];
                tans=num;
            }
            if(tans<ans)
            {
                ans=tans;
                ll=tleft;
            }
            else if(tans==ans&&tleft>ll)
            {
                ll=tleft;
            }
        }
    }
    left[t][flag]=ll;
    return dp[t][flag]=ans;
}
int main()
{
   // freopen("dd.txt","r",stdin);
    int ncase,time=0;
    scanf("%d",&ncase);
    while(ncase--)
    {
        printf("Scenario #%d:\n",++time);
        memset(dp,-1,sizeof(dp));
        scanf("%d%d%d",&n,&c[0],&c[1]);
        for(int i=1;i<=n;i++)
        scanf("%d",&v[i]);
        int limit=(1<<n)-1;
        int ans=inf;
        for(int i=0;i<=limit;i++)
        {
            int tmp=max(dfs(i,0),dfs(limit-i,1));
            ans=min(ans,tmp);
        }
        printf("%d\n\n",ans);
    }
    return 0;
}

http://poj.org/problem?id=3229

poj 3229

此题题意飘忽不定，很难把握，我感觉很难在不看discuss的情况下1Y，其实就是建图后一个类似于TSP问题的题，不过题目加了一点就是在每个节点还有一个停留时间，然后需要注意的是这题从原点出发最后回到一点只要求一次原点的停留时间，还有不是必须要访问所有点，每个点可以经过无数次，所以我们建完图后要用floyd预处理一下，其他就没什么好讲得了吧，其实题目并不难，关键还是题意太模糊，搞得人不太敢去做。这道题类似于ｐｏｊ3311（题解这里有http://blog.csdn.net/dyx404514/article/details/8758376），很简单的状态转移，这里就不重复了。代码如下：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#define inf 2100000000
using namespace std;
int n,m,k;
double map[16][16];
int time[16];
double dp[15][1<<14];
double min(double a,double b)
{
    return a<b?a:b;
}
int max(int a,int b)
{
    return a>b?a:b;
}
void floyd()
{
    int i,j,k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
            {
                map[j][k]=min(map[j][i]+map[i][k],map[j][k]);
            }
        }
    }
}
int getnum(int x)
{
    int sum=0;
    while(x)
    {
        sum+=x%2;
        x/=2;
    }
    return sum;
}
double dfs(int now,int flag)
{
    if(dp[now][flag]>0)
    return dp[now][flag];
    if((1<<(now-1))==flag)
    {
        if(map[0][now]==inf)
        return dp[now][flag]=inf;
        return dp[now][flag]=map[0][now]+time[now];
    }
    double ans=inf;
    int i;
    for(i=1;i<n;i++)
    {
        if(i!=now&&((1<<(i-1))&flag)&&map[i][now]!=inf)
        {
            ans=min(ans,time[now]+map[i][now]+dfs(i,flag^(1<<(now-1))));
        }
    }
    return dp[now][flag]=ans;
}
int main()
{
   // freopen("dd.txt","r",stdin);
    while(scanf("%d%d%d",&n,&m,&k))
    {
        if(n==0&&m==0&&k==0)
        break;
        k*=12;
        int limit=0;
        int i,x,j;
        for(i=1;i<=m;i++)
        {
            scanf("%d",&x);
            if(x!=1)
            limit+=1<<(x-2);
        }
        memset(dp,0,sizeof(dp));
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            map[i][j]=inf;
        }
        for(i=0;i<n;i++)
        {
            map[i][i]=0;
            scanf("%d",&time[i]);
        }
        int a,b,d,t;
        while(scanf("%d%d%d%d",&a,&b,&d,&t))
        {
            if(a+b+d+t==0)
            break;
            if(t)
            {
                double tt=(double)d/120;
                if(map[a-1][b-1]>tt)
                map[a-1][b-1]=map[b-1][a-1]=tt;
            }
            else
            {
                double tt=(double)d/80;
                if(map[a-1][b-1]>tt)
                map[a-1][b-1]=map[b-1][a-1]=tt;
            }
        }
        floyd();
        int tmp=(1<<(n-1))-1;
        int ans=-1;
        for(i=0;i<=tmp;i++)
        {
            if((i&limit)==limit)
            {
                for(j=1;j<n;j++)
                {
                    if(map[j][0]!=inf&&(i&(1<<(j-1))))
                    {
                        if(map[j][0]+dfs(j,i)+time[0]<=(double)k)
                        {
                            ans=max(ans,getnum(i)+1);
                        }
                    }
                }
            }
        }
        if(ans==-1)
        printf("No Solution\n");
        else
        printf("%d\n",ans);

    }
    return 0;
}