状态压缩DP总结

 

POJ1185 炮兵部队问题：

在平原上才能放置炮兵，每个炮兵的上下左右2格之内都不能出现别的炮兵

可以考虑在当前行放置炮兵它的右侧和下侧绝对不会出现炮兵即可，左侧和上侧就能省去考虑

明显的状态压缩dp题，但是题目所给的有10列，因为每行都与前两行的状态有关，那么也就是根据当前，上一行，上上行3行状态来修改

dp[i][v][u]的状态方程

因为这里直接3重循环会爆，但是我们很容易发现，可以预处理一些关于行的合法状态，那么状态数就少了很多，接下来考虑的时候就省去了行上的相关影响

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int N = 1<<11;
int dp[105][100][100] , state[N];
int can[100] , tot[100] , cnt;
char str[15];

void init_dfs(int k , int u , int v)
{
    if(k<0){
        tot[cnt] = v;
        can[cnt++] = u;
        return;
    }
    init_dfs(k-3 , u|(1<<k) , v+1);
    init_dfs(k-1 , u , v);
}

int main()
{
 //   freopen("a.in" , "r" , stdin);
    int n,m;
    while(scanf("%d%d" , &n , &m) != EOF)
    {
        for(int i=1 ; i<=n ; i++){
            scanf("%s" , str);
            state[i] = 0;
            for(int j=0 ; j<(int)strlen(str) ; j++){
                state[i] <<= 1;
                if(str[j] == 'P') state[i]+=1;
            }
           // cout<<"state: "<<state[i]<<endl;
        }
        //找到所有符合的状态，减少状态数
        cnt = 0;
        init_dfs(m-1 , 0 , 0);
     //   cout<<cnt<<endl;

        if(n==1){
            int maxn=0;
            for(int i=0 ; i<cnt ; i++)
                if((state[1]&can[i]) == can[i])
                    maxn = max(maxn , tot[i]);
            printf("%d\n" , maxn);
            continue;
        }

        memset(dp , 0 , sizeof(dp));
        for(int i=0 ; i<cnt ; i++){
            for(int j=0 ; j<cnt ; j++){
                int t1 = state[1]&can[i] , t2 = state[2]&can[j];
                if(t1 == can[i] && t2 == can[j] && !(can[i]&can[j]))
                {
                   // cout<<"test: "<<i<<" "<<j<<" "<<can[i]<<" "<<can[j]<<" tot: "<<tot[i]<<" "<<tot[j]<<endl;
                    dp[2][i][j] = tot[i] + tot[j];
                }
            }
        }
        state[0] = (1<<m)-1;
        for(int i=3 ; i<=n ; i++){
            for(int u=0 ; u<cnt ; u++){
                if((state[i]&can[u]) < can[u]) continue;
                for(int v=0 ; v<cnt ; v++){
                    if((state[i-1]&can[v]) < can[v]) continue;
                    if((can[v]&can[u])) continue;
                    for(int w=0 ; w<cnt ; w++){
                        if((state[i-2]&can[w]) < can[w]) continue;
                        if((can[v]&can[w]) || (can[u]&can[w])) continue;
                        dp[i][v][u] = max(dp[i][v][u] , dp[i-1][w][v] + tot[u]);
                    }
                }
            }
        }
        int maxn = 0;
        for(int i=0 ; i<cnt ; i++){
            for(int j=0 ; j<cnt ; j++)
                maxn = max(maxn , dp[n][i][j]);
        }
        printf("%d\n" , maxn);
    }
    return 0;
}

POJ 2411 木板拼接问题：

在n*m的方格中，放1*2或者2*1的木板，问有多少摆放的种数

题目会超int，答案输出用long long

这里用dp[i][u]表示到达第 i 行时状态为 u ，且前面行的格子已经全部被木板填充完全，所能达到的方法种数

每次对于当前行的状态只跟上一行有关，dp[i+1][u] += dp[i][v] 

通过v可以拼出 u 的情况，我们总是在u，v上放2*1的板，或只在u 上放1*2的板，不能在v上放1*2的板，这样会与原来 v 作为当前行时在其上放1*2的情况重复

且必须保证全部放完后，上一行v 全部填充满（v == (1<<m)-1) ，才更新数据

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define ll long long
ll dp[15][10005];

void dfs(int i , int u , int v , int full , int k , ll val)
{
    if(k<0){
        if(v == full) dp[i][u] += val;
        return ;
    }
    if(k>=1 && !(u&(3<<(k-1)))) dfs(i , u|(3<<(k-1)) , v , full ,k-2 , val);
    if(!(u&(1<<k)) && !(v&(1<<k))) dfs(i , u|(1<<k) , v|(1<<k) , full , k-1 , val);
    if(!(v&(1<<k))) return ;
    dfs(i , u , v , full , k-1 , val);
}

int main()
{
  //  freopen("a.in" , "r" , stdin);
    int n,m;
    while(scanf("%d%d" , &n , &m) ,n||m)
    {
        memset(dp , 0 , sizeof(dp));
        dfs(1 , 0 , (1<<m)-1 , (1<<m)-1 , m-1 , 1);
        for(int i=2 ; i<=n ; i++){
            for(int j=0 ; j<(1<<m) ; j++){
                if(dp[i-1][j]) dfs(i , 0 , j , (1<<m)-1 , m-1 , dp[i-1][j]);
            }
        }
        printf("%I64d\n" , dp[n][(1<<m)-1]);
    }
    return 0;
}

HDU2280 填充问题：

将所给的积木装入平面上，保证最后剩余的格数能够尽可能的少

因为积木最大也就两行，所以每次当前行只受上一行的影响

dp[i][u]记录当前 i 行 状态 为 u 时剩余的格子的最小数目

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1005;

int dp[N][40] , state[N];
char str[8];

int cnt_0(int u)
{
    int ans = 5;
    while(u){
        if(u&1) ans--;
        u>>=1;
    }
    return ans;
}

void dfs1(int i , int u , int cnt , int k) //k为当前的长度，从0开始
{
    if(k < 0){
        dp[i][u] = min(dp[i][u] , cnt);
        return ;
    }
    if(k >= 1 && !(u&(3<<(k-1)))){
        int v = u|(3<<(k-1));
        dfs1(i , v , cnt-2 , k-2);
    }
    dfs1(i,u,cnt,k-1);
}
//u为当前行状态，v为上一行状态,cnt为当前行0的数量
void dfs2(int i , int u , int v , int cnt , int k)
{
    if(k < 0){
        dp[i][u] = min(dp[i][u] , cnt);
        return ;
    }
    if(k>=1){
        if(!(u&(3<<(k-1)))){
            int p = u|(3<<(k-1));
            dfs2(i , p , v , cnt-2 , k-2);
        }
        if(!(u&(3<<(k-1))) && !(v&(1<<(k-1)))){
            int p = u|(3<<(k-1));
            int q = v|(1<<(k-1));
            dfs2(i , p , q , cnt-3 , k-2);
        }
        if(!(u&(3<<(k-1))) && !(v&(1<<k))){
            int p = u|(3<<(k-1));
            int q = v|(1<<k);
            dfs2(i , p , q , cnt-3 , k-2);
        }
        if(!(v&(3<<(k-1))) && !(u&(1<<(k-1)))){
            int p = u|(1<<(k-1));
            int q = v|3<<(k-1);
            dfs2(i , p , q , cnt-3 , k-2);
        }
        if(!(v&(3<<(k-1))) && !(u&(1<<k))){
            int p = u|(1<<k);
            int q = v|(3<<(k-1));
            dfs2(i , p , q , cnt-3 , k-1);
        }
    }
    if(!(u&(1<<k)) && !(v&(1<<k))){
        int p = u|(1<<k);
        int q = v|(1<<k);
        dfs2(i , p , q , cnt-2 , k-1);
    }
    dfs2(i , u , v , cnt , k-1);
}

int main()
{
  //  freopen("a.in" , "r" , stdin);
    int n , m;
    while(scanf("%d%d" , &n , &m) != EOF)
    {
        for(int i=1 ; i<=n ; i++){
            state[i] = 0;
            scanf("%s" , str);
            for(int j=0 ; j<5 ; j++){
                int t = str[j]-'0';
                state[i] = state[i]*2+t;
            }
        }

        memset(dp , 0x3f , sizeof(dp));
        dp[1][state[1]] = cnt_0(state[1]);
        dfs1(1 , state[1] , dp[1][state[1]] , 4);

        for(int i=2 ; i<=n ; i++){
            for(int p=0 ; p<32 ; p++){
                if(dp[i-1][p] <INF){
                  //  cout<<"state : i: "<<i<<" p: "<<p<<" "<<dp[i-1][p]+cnt_0(state[i])<<endl;
                    dfs2(i , state[i] , p , dp[i-1][p]+cnt_0(state[i]) , 4);
                }
            }
        }
        int minn = INF;
        for(int i=0 ; i<32 ; i++)
            minn = min(minn , dp[n][i]);
     //   cout<<minn<<endl;
        printf("%s\n" , minn<=m?"YES":"NO");
    }
    return 0;
}

 HDU 2442 方格填充

通过所给的5种形式的木块无覆盖填充n*m的方格，问最多有多少方格被填充

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int N = 1<<6;
int dp[105][N][N];

void dfs(int i , int w , int v , int u , int val , int k)
{
    if(k<0){
        dp[i][v][u] = max(dp[i][v][u] , val);
        return;
    }
    if(k>=2){
        if(!(w&(1<<(k-1))) && !(v&(7<<(k-2))) && !(u&(1<<(k-1))))
            dfs(i , w|(1<<(k-1)) , v|(7<<(k-2)) , u|(1<<(k-1)) , val+5 , k-3);
        if(!(v&(7<<(k-2))) && !(u&(1<<(k-1))))
            dfs(i , w , v|(7<<(k-2)) , u|(1<<(k-1)) , val+4 , k-3);
        if(!(v&(7<<(k-2))) && !(u&(1<<k)))
            dfs(i , w , v|(7<<(k-2)) , u|(1<<k) , val+4 , k-3);
    }
    if(k>=1){
        if(!(w&(1<<k)) && !(v&(3<<(k-1))) && !(u&(1<<k)))
            dfs(i , w|(1<<k) , v|(3<<(k-1)) , u|(1<<k) , val+4 , k-2);
        if(!(w&(3<<(k-1))) && !(v&(1<<k)) && !(u&(1<<k)))
            dfs(i , w|(3<<(k-1)) , v|(1<<k) , u|(1<<k) , val+4 , k-1);
    }
    dfs(i , w , v , u , val , k-1);
}

int main()
{
  //  freopen("a.in" , "r" , stdin);
    int n,m;
    while(scanf("%d%d" , &n , &m) == 2)
    {
        memset(dp , -1 , sizeof(dp));
        dp[1][(1<<m)-1][0] = 0;
        for(int i=2 ; i<=n ; i++){
            for(int w=0 ; w<(1<<m) ; w++){
                for(int v=0 ; v<(1<<m) ; v++){
                    if(dp[i-1][w][v]>=0) dfs(i , w , v , 0 , dp[i-1][w][v] , m-1);
                }
            }
        }
        int ans = 0;
        for(int v=0 ; v<(1<<m) ; v++)
            for(int u=0 ; u<(1<<m) ; u++)
                ans = max(ans , dp[n][v][u]);
        printf("%d\n" , ans);
    }
    return 0;
}