状态压缩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预处理一下,其他就没什么好讲得了吧,其实题目并不难,关键还是题意太模糊,搞得人不太敢去做。这道题类似于poj3311(题解这里有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;
}


 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我们来看一个具体的例子。假设有一个长度为 n 的数组 A,其中每个元素都是 0 或 1,现在需要求出所有长度为 k 的子串中,元素为 1 的个数的最小值。 传统的动态规划方法需要使用二维数组来记录状态,时间复杂度为 O(nk),空间复杂度为 O(nk)。而使用状态压缩dp,我们可以将状态压缩为一个长度为 n 的二进制数 i,其中第 j 位为 1 表示 A[j] 在当前子串中出现了一次或多次,为 0 则表示没有出现。因此,我们只需要使用一个一维数组 f 来记录当前状态的最小值即可。 具体实现如下: ```python def min_ones_in_k_substrings(A, k): n = len(A) f = [float('inf')] * (1 << n) f[0] = 0 for i in range(n): for j in range(1 << i): if bin(j).count('1') == k: ones = bin(j & ((1 << i) - 1)).count('1') + A[i] f[j] = min(f[j], f[j & ~(1 << i)] + ones) return f[(1 << n) - 1] ``` 其中,f[i] 表示状态为 i 时的最小值,初始化为正无穷。在状态转移时,我们枚举当前状态的所有子集 j,如果 j 中的元素个数等于 k,则计算 j 中包含的所有元素为 1 的个数 ones,然后更新 f[j] 的值为 f[j] 和 f[j - {i}] + ones 中的较小值。其中,j - {i} 表示将 j 中的第 i 位(即 A[i] 对应的位置)置为 0。 最终,我们返回状态为全集时的最小值 f[(1 << n) - 1] 即可。由于状态总数为 2^n,因此时间复杂度为 O(n^22^n),空间复杂度为 O(2^n)。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值