状压dp

最新推荐文章于 2024-03-06 22:08:55 发布
最新推荐文章于 2024-03-06 22:08:55 发布
阅读量127 收藏 1
点赞数
原文链接：http://www.cnblogs.com/Akaina/p/11374131.html
版权

状压dp

当题目中的某一项的值极小（小于等于\(20\)）时考虑使用状压\(dp\)

状压\(dp\)是二维时一般是

\(dp[i][s]\)表示进行到第\(i\)步且第\(i\)步的状态为\(s\)时的\(dp\)值

状压\(dp\)由于是二进制，多与位运算的操作有关

以下是一些常见的位运算操作：

\(1.s\&(1<<i)\) 判断第\(i\)位是否为\(1\)

\(2.s=s | (1<<i)\)把第i位设为\(1\)

\(3.s=s\&(~(1<<i))\)把第\(i\)位设为\(0\)

\(4.s=s\)^\((1<<i)\)把第\(i\)位的值取反

\(5.s=s\&(s-1)\)把\(s\)二进制下最靠右的一个\(1\)去掉

\(6.for(s0=s;s0;s0=(s0-1)\&s)\)枚举\(s\)的子集

\(7.x\&-x\)取出最低位的\(1\)

例题

互不侵犯 洛谷P1896

\(f[i][k][s]\)表示前\(i\)行放了\(k\)个国王，当前行状态为s的方案数

#include <iostream>
#include <cstdio>
using namespace std;
int n,King,tot=0;
int s[1050],pd[1050];
int num[15];
long long ans=0;
long long f[10][105][1050];
void Deal_first()
{
    for(int i=0;i<(1<<n);i++)
    {
        int cnt=0,x=i;
        pd[i]=1;
        while(x!=0)
        {
            num[++cnt]=x%2;
            x/=2;
        }
        for(int j=1;j<cnt;j++)
        {
            if(num[j]==num[j+1]&&num[j]==1)
            {
                pd[i]=0;break;
            }
            if(num[j]==1)s[i]++;
        }
        if(pd[i]==1)if(num[cnt]==1)s[i]++;
    }
}
int main()
{
    scanf("%d%d",&n,&King);tot=(1<<n)-1;
    Deal_first();
    for(int i=0;i<=tot;i++)if(pd[i]==1)f[1][s[i]][i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=tot;j++)
        {
            for(int k=0;k<=tot;k++)
            {
                if(!pd[j])continue;if(!pd[k])continue;
                if(((j|(j<<1)|(j>>1))&k)!=0)continue;
                for(int t=King;t>=s[j];t--)f[i][t][j]+=f[i-1][t-s[j]][k];
            }
        }
    }
    for(int i=0;i<=tot;i++)
    {
        if(pd[i])ans+=f[n][King][i];
    }
    printf("%lld",ans);
    return 0;
}

愤怒的小鸟 洛谷P2831

显然，因为原点加两个点即可确定抛物线，故抛物线的数量最多为\(n^2\)条，又因为\(n<=18\),

故考虑用状压\(dp\),枚举抛物线，复杂度为\(O（T\times n^2\times2^n)\)

但考虑到每个猪都要被打，所以可以从小到大枚举\(S\)，每次每次打掉编号最小的还没消灭的猪，
由于包含该猪的抛物线只有\(O(n)\)种，所以时间复杂度为\(O(n*2^n)\)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define lld long double
#define eps 1e-8
int dp[1<<19],line[20][20];
lld x[20],y[20];
int n,m;
int lowbit(int x)
{
    return x&(-x);
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
    scanf("%d%d",&n,&m);
    lld z=eps;
    memset(dp,0x3f3f3f3f,sizeof(dp));
    memset(line,0,sizeof(line));
    dp[0]=0;
    for(int i=1;i<=n;i++)
    {
        //scanf("%lf%lf",&x[i],&y[i]);//double用这个
        cin>>x[i]>>y[i];//long double用这个
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(fabs(x[i]-x[j])<eps)continue;
            lld a=y[j]/(x[j]*(x[j]-x[i]))-y[i]/(x[i]*(x[j]-x[i]));
            lld b=(y[i]-a*x[i]*x[i])/x[i];
            if(a>-eps)continue;
            for(int k=1;k<=n;k++)
                if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<eps)line[i][j]|=(1<<(k-1));
        }
    }
   for(int i=0;i<(1<<n);i++)
    {
        int x=-1;
        for(int j=1;j<=18;j++)
        {
            if((i&(1<<(j-1)))==0)
            {
                x=j;break;
            }
        }
        if(x==-1)continue;
        dp[i|(1<<(x-1))]=min(dp[i|(1<<(x-1))],dp[i]+1);
        for(int j=1;j<=n;j++)dp[i|line[x][j]]=min(dp[i|line[x][j]],dp[i]+1);
    }
    printf("%d\n",dp[(1<<n)-1]);
    }
    return 0;
}

玉米田

题目链接

题意：一块\(n\times m\)的牧场，有的方格可以种草，有的不能种，且任意种草的方格不能有公共边，求方案数

\(1<=n,m<=12\)

\(m\)极小，故可以用状压\(dp\)
设\(f[i][j]\)表示前i行符合条件且第\(i\)行的状态为\(j\)的方案数
预处理\(cnt[i]\)表示在不管其它行的情况下第\(i\)行符合条件的状态数，\(g[i][j]\)表示第i行符合条件的第j个状态
在转移时需满足\(g[i-1][j]\&g[i][k]==0\)

#include <iostream>
#include <cstdio>
using namespace std;
#define mol 100000000
int n,m;
int a[15][15];
int h[15],cnt[15];
int g[15][1<<15],f[15][1<<15];
void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
    {
        int sum=0;
        for(int j=1;j<=m;j++)
        {
            sum=sum*2+a[i][j];
        }
        h[i]=sum;
    }
}
void Deal_first()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<m)-1;j++)
        {
              int pd=1;
              if((j|h[i])==h[i])
              {
                  if(((j&(j<<1))==0)&&((j&(j>>1))==0))pd=0;
                  if(!pd)g[i][++cnt[i]]=j;
              }
        }
    }
    for(int i=1;i<=cnt[1];i++)f[1][g[1][i]]=1;
}
int main()
{
    read();
    Deal_first();
    for(int i=2;i<=n;i++)
    {
        for(int j=1;j<=cnt[i-1];j++)
        {
            for(int k=1;k<=cnt[i];k++)
            {
                if((g[i-1][j]&g[i][k])==0)
                {
                    f[i][g[i][k]]=(f[i][g[i][k]]+f[i-1][g[i-1][j]])%mol;
                }
            }
        }
    }
    int ans=0;
    for(int i=1;i<=cnt[n];i++)ans=(ans+f[n][g[n][i]])%mol;
    printf("%d\n",ans);
    return 0;
}

炮兵阵地

题目链接

题意：在\(n \times m\)的网格地图中部署炮兵部队，只能在平原地形上部署，每支炮兵部队能攻击沿横向左右各两格，沿纵向上下各两格，求最多能部署多少支炮兵部队。

玉米田的变式题。

因为前面两行都会对当前行产生影响，故\(dp\)要多记录一维，但是\(f[110][1024][1024]\)会炸空间

但发现每一行合法的状态最多\(59\)种，故只需用\(f[110][70][70]\)来记录

预处理\(cnt[i]\)表示在不管其它行的情况下第i行符合条件的状态数，\(g[i][j]\)表示第i行符合条件的第j个状态

我一开始把状态编号和状态搞混了，调错调了半天。

#include <iostream>
#include <cstdio>
using namespace std;
int n,m;
char ch[110][15];
int h[110],cnt[110];
int g[110][1<<12];
int num[1<<12]={};
int f[110][70][70];
void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%s",ch[i]+1);
}
void Deal_first()
{
    for(int i=1;i<=n;i++)
    {
        int sum=0;
        for(int j=1;j<=m;j++)
        {
            if(ch[i][j]=='P')sum=sum*2+1;
            else sum=sum*2;
        }
        h[i]=sum;
    }
    for(int i=1;i<=(1<<m)-1;i++)
    {
        int cnt=0;
        for(int j=1;j<=m;j++)
        {
            if((i&(1<<(j-1)))!=0)cnt++;
        }
        num[i]=cnt;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<m)-1;j++)
        {
            if((j|h[i])==h[i])//
            {
                if((((j<<2)&j)==0)&&(((j<<1)&j)==0)&&(((j>>2)&j)==0)&&(((j>>1)&j)==0))g[i][++cnt[i]]=j;
            }
        }
    }
    for(int i=1;i<=cnt[1];i++)
    {
        for(int j=1;j<=cnt[2];j++)
        {
            if((g[1][i]&g[2][j])==0)f[2][j][i]=num[g[1][i]]+num[g[2][j]];
        }
    }
}
int main()
{
    read();
    Deal_first();
    for(int i=3;i<=n;i++)
    {
        for(int j=1;j<=cnt[i];j++)
        {
            for(int k=1;k<=cnt[i-1];k++)
            {
                if((g[i][j]&g[i-1][k])==0)
                {
                    for(int t=1;t<=cnt[i-2];t++)
                    {
                        if(((g[i][j]&g[i-2][t])==0)&&((g[i-1][k]&g[i-2][t])==0))
                        {
                            f[i][j][k]=max(f[i][j][k],f[i-1][k][t]+num[g[i][j]]);
                        }
                    }
                }
            }
        }
    }
    int ans=0;
    for(int j=1;j<=cnt[n];j++)
    {
        for(int k=1;k<=cnt[n-1];k++)
        {
            if((g[n][j]&g[n-1][k])==0)
            {
                ans=max(ans,f[n][j][k]);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

动物园

题目链接

题意：

动物园的围栏呈环状排列

每个小朋友可以看到从他所在位置开始数的连续5个围栏，每个小朋友有他害怕或喜欢的动物。

当下面两处情况之一发生时，小朋友就会高兴：

  • 至少有一个他害怕的动物被移走
  • 至少有一个他喜欢的动物没被移走

你可以选择去移走一些围栏，使得最多的小朋友高兴

围栏数为\(N (1≤N≤10 000)\)，小朋友的个数为\(C (1≤C≤50 000)\)

经过观察发现围栏数极小，故可以用状压\(dp\)

设\(f[i][j]\)表示第i个小朋友可以看到的动物被移走的状态为\(j\)

预处理\(s[i][j]\)表示第i个位置的所有小朋友可以看到的动物被移走的状态为j时会高兴的小朋友数量

先枚举第n个小朋友的状态，再进行\(dp\)

\(dp\)方程为

        for(int j=1;j<=n;j++)
        {
            for(int k=0;k<32;k++)
            f[j][k]=max(f[j-1][(k&15)<<1],f[j-1][((k&15)<<1)|1])+s[j][k];
        }

整道题的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n,m;
int s[10100][35];
int f[10100][35];
int ans=0;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int e,f,l;scanf("%d%d%d",&e,&f,&l);
        int x=0,y=0;
        for(int j=1;j<=f;j++)
        {
            int xx;scanf("%d",&xx);
            x=x|(1<<((xx-e+n)%n));
        }
        for(int j=1;j<=l;j++)
        {
            int xx;scanf("%d",&xx);
            y=y|(1<<((xx-e+n)%n));
        }
        for(int j=0;j<32;j++)
        {
            s[e][j]+=((x&j)||(y&((~j)&31)));
        }
    }
    for(int i=0;i<32;i++)
    {
        memset(f,-0x3f3f3f3f,sizeof(f));
        f[0][i]=0;
        for(int j=1;j<=n;j++)
        {
            for(int k=0;k<32;k++)f[j][k]=max(f[j-1][(k&15)<<1],f[j-1][((k&15)<<1)|1])+s[j][k];
        }
        ans=max(ans,f[n][i]);
    }
    printf("%d\n",ans);getchar();
    return 0;
}

学校食堂

题目链接

同学们排队在食堂吃饭，每个同学想吃的菜都有一个特定的口味值T[i],每个同学的菜所需的时间为T[i]^T[j]（T[j]表示食堂做的前一道菜的口味值）,每个同学有一定的忍耐值B[i]，表示他最多允许他身后的B[i]个人先拿到饭菜。

求在满足所有人的忍耐值的前提下，学校食堂做完这些菜最少需要多少时间。

对于100%的数据，满足\(1 ≤ N ≤ 1,000，0 ≤ Ti ≤ 1,000，0 ≤ Bi ≤ 7。\)

我们通过观察发现\(B[i]\)的值极小，考虑状压\(dp\)

这道题最大的一个难点就是\(dp\)方程怎么列

首先我们考虑至少有一维是[i]且前i-1个人的菜已经做完了，肯定还有一维[j]用于状态压缩表示这个人和他身后的B[i]个人拿到菜的情况，又因为做菜时间与上一个拿到饭菜的人有关，所以再记录一维\([k]\)表示上一个拿到饭菜的人相对第i个人的位置，经过分析可得k的范围是\([-8,7]\)。(作为数组下标时需整体加8)

所以\(f[i][j][k]\)表示前i-1个人已经拿到饭菜了，第\(i\)个人到第\(i+B[i]\)个人拿到饭菜的情况为\(j\)，上一个拿到饭菜的人为第\(i+k\)个人

考虑状态方程如何转移：

如果\(j\&1==1\)，那么\(f[i][j][k]\)可以等价地转移到\(f[i+1][j>>1][k-1]\)

如果\(j\&1==0\)，枚举下一个拿到饭菜的人，注意用\(B[i]\)来限制枚举的范围

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int n;
int T[1010],B[1010];
int f[1070][1<<10][20];
int main()
{
    int Case;scanf("%d",&Case);
    while(Case--)
    {
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&T[i],&B[i]);
    memset(f,0x3f3f3f3f,sizeof(f));
    f[1][0][7]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<8)-1;j++)
        {
            for(int k=-8;k<=7;k++)
            {
                if(f[i][j][k+8]>=1e9)continue;
                if(j&1)f[i+1][j>>1][k+7]=min(f[i+1][j>>1][k+7],f[i][j][k+8]);
                else
                {
                    int cnt=1e9;
                    for(int t=0;t<=7;t++)
                    {
                        if(i+t>cnt)break;
                        if((j>>t)&1)continue;
                        cnt=min(cnt,i+t+B[i+t]);
                        f[i][j|(1<<t)][t+8]=min(f[i][j|(1<<t)][t+8],f[i][j][k+8]+((i+k>0)?(T[i+k]^T[i+t]):0));
                    }
                }
            }
        }
    }
    int ans=1e9;
    for(int i=-8;i<=0;i++)ans=min(ans,f[n+1][0][i+8]);
    printf("%d\n",ans);
    }
    return 0;
}

转载于:https://www.cnblogs.com/Akaina/p/11374131.html

dbp123123
关注
状压DP学习笔记（一）
天空の行者
08-03 858
首先，什么是状压。所谓状压，就是状态压缩。就是将原来需要很多东西来储存的状态存在一个很小的空间内，并且并不影响动态规划的决策和转移。最简单的例子就是可以将一个地方是否有东西表示成二进制位中的一位。很多东西都可以用状态的压缩，有时不仅仅是DP。举个最简单的例子，USACOchecker这道题，就有一种方法就是用二进制位来确定无法放置的位置，实际
关于状压
qq_38643745的博客
05-18 435
** 动态规划——状态压缩 ** 这里引入集合的概念，此集合可以理解为元素的状态集合 直接例题 EXAMPEL 1. 铺砖块 题目描述 现有n*m的一块地板，需要用1*2的砖块去铺满，中间不能留有空隙。问这样方案有多少种 输入 输入n，m（1 有多组输入数据，以m=n=0结束 输出 输出铺砖块的方案数 样例输入 1 2
[状压DP]
weixin_34037515的博客
03-14 105
总述 状压 + DP = 状压DP 状态压缩动态规划，就是我们俗称的状压DP，是利用计算机二进制的性质来描述状态的一种DP方式 很多棋盘问题都运用到了状压，同时，状压也很经常和ＢＦＳ及ＤＰ连用，例题里会给出介绍 有了状态，DP就比较容易了 举个例子：有一个大小为n*n的农田，我们可以在任意处种田，现在来描述一下某一行的某种状态： 设n = 9；有二进制数 100011011（九位），每...
状压DP
Olga_jing的博客
02-26 407
题目：链接 炮兵阵地 Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 22877   Accepted: 8849 Description 司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用
状压DP_C++_算法_状压_状态压缩DP_状压DP_
09-30
**状压DP（动态规划状态压缩）是一种在解决动态规划问题时优化空间复杂度的方法，尤其适用于当状态之间有大量重叠或者状态数量极其庞大时。C++是实现这一算法的常用编程语言，其强大的模板机制和高效性能使得在处理...
【c++提高1】优化DP专题：状压DP & 倍增优化DP & 环形DP的单调队列优化DP
小学生蒟蒻
07-11 824
这是c++提高的第一讲动态规划是解决“多阶段决策最优化问题”的一种算法思想。阶段的划分决定了状态的定义，状态定义的一个重要特性就是要确保**“无后效性”。** 很多DP问题在定义状态的时候，为了确保无后效性，需要在状态中加入多个维度，如果每个维度都用一维数组来表示的话，当维度较多时会导致占用的空间太大。 很多时候状态的维度虽然很多，但是决策非常少，特别的很多时候只有两种决策。例如背包问题中每个物品只有0和1两种决策。对于这种情况，没有必要为每个维度都分配一维空间，而是用一个二进制数来存储所有维度，每个二进制
【状压DP】易懂讲解状态压缩/状态压缩DP
qq_35684989的博客
05-31 3269
本文是状态压缩DP的总结
【状压DP】状态压缩动态规划入门超详解
繁凡さん的博客
03-15 9949
状压DP一、概述1.状态压缩2.使用条件3.状压DP二、位运算三、例题引入入门例题【例1】填满棋盘入门例题【例二】玉米地 感觉好多讲状压DP的博客都有点乱，我就结合各路大佬的博客，加上我自己的理解，总结出一篇博客来，供初学者参考 一、概述 1.状态压缩 状态压缩就是使用某种方法，简明扼要地以最小代价来表示某种状态，通常是用一串01数字（二进制数）来表示各个点的状态。这就要求使用状态压缩的对象的点的...
状压dp小结
qlq-polo
10-28 524
今天模拟又考了一个SPFA+状压dp，巧了，我又不会，华丽丽爆零。（实际上我啥都不会） 状压dp即用二进制暴力枚举然后状态转移。用f[i][j]表示第i行在状态j的时候的方案数，其中j用一个二进制数来表示。转移的时候只要判断与当前行和上一行(或是上几行)是否冲突即可，如果不冲突，f[i][j]=∑f[i−1][q]其中q为不冲突的状态。∑1≤i≤cnt​f[n][i] 就是最后的答案，cnt为总状...
dp之状压
weixin_43331783的博客
07-20 422
1. ｄｐ 状压 　* A - Corn Fields POJ - 3254 　* B - 炮兵阵地 POJ - 1185 　* C - Hie with the Pie POJ - 3311 　* D - Travelling HDU - 3001　 　* E - Islands and Bridges POJ - 2288 状压 状压目前有两种，一种比如ＡＢ就是把状态转换...
状压 bfs
liluoyu_1016的博客
07-31 419
http://119.23.43.230/problem.php?id=1234 题目描述 小z喜欢上了一个迷宫游戏，这个游戏是这样的，有一个N*M的迷宫(即N行M列的迷宫)保证0&lt;N&lt;=500,0&lt;M&lt;=500 左上角坐标(1,1)为入口，右下角坐标(N,M)为出口，这个迷宫和一般迷宫不同的地方是， 迷宫种可能会出现k个宝石(0&lt;=k&lt;=3),小z如果...
状压小技巧
panjd123
08-23 493
m个状态的全集 111…111 (1&lt;&lt;m)-1; 状态压缩 s|=(1&lt;&lt;(x-1)); 枚举子集 for(int i=s;i;i=(i-1)&amp;s) ; ¬s¬s¬s U^s; 枚举包含s的集合S s的补集的子集和s的按位或 可以理解为一点点补上去 int tmp=s^((1&lt;&lt;m)-1); for(int i=tmp;i;i=(...
状压DP入门
PK__PK的博客
03-02 416
状态压缩：现在有一些物品，若我们选择某件物品，则这件物品为1，不选则为0。那么对于这些物品的选择的状态可以表示为0 0 0 1 1。这个表示选择第1件物品和第2件物品，其余的不选。对于所有状态都可以这样表示。而这些状态我们可以把他看成一个10进制的数。如例子中的状态，就可以表示为3,3的二进制为00011,这样就把状态压缩了。不需要用数组去表示是否选择物品。 例题：有一个N*M(N 我
状压DP自学笔记
B.W.Z
10-25 705
状态压缩，如名，将一些在程序中难于表示但却易于表示（？！不要急，往下看）的状态通过数组进行存储，往往与DP配合食用
状压dp详解，棋盘式、集合型，OJ详解
最新发布
EQUINOX1的博客
03-06 1769
状压dp问题
状压小结
AlanXWu的博客
08-17 361
使用条件：小数据  &lt;17 tip：如何遍历一个状态的子状态                k:=i;               while k&gt;0 do begin                    k:=(k-1) and i                    end;...
状压dp入门
weixin_45434743的博客
02-06 842
状压dp入门 什么是状态压缩dp？ 状态压缩dp就是把某些用dfs会超时的递归调用过多的题目转换成用数组中的一位数表示状态。我们知道在二进制下每一位上不是0就是1，这样就可以很好的表示事物的状态，是存在还是不存在，状态压缩就是把状态压缩到一位数内，这一位数操作时都用二进制操作。 要学状态压缩dp首先要对二进制有所了解。我们下面来介绍一下二进制的相关知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2
状压DP问题
Never say never
08-17 1481
状态压缩·一题目传送：#1044 : 状态压缩·一AC代码：#include <map> #include <set> #include <list> #include <cmath> #include <deque> #include <queue> #include <stack> #include <bitset> #include <cctype> #include <cstdio> #in
状压DP一般分为哪几类
06-11
状压DP一般可以分为以下几类： 1. 状态压缩表示状态：将一个状态压缩成一个整数，用二进制表示状态中的每个元素，将其转化为一个整数，方便状态转移和空间压缩。 2. 状态压缩表示集合：将一个集合压缩成一个整数，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值