c++状态压缩dp

这是一个经典的问题，可以用dp来解决。

设 $f_{i,j}$ 表示第 $i$ 行，状态为 $j$ 时的方案数，其中 $j$ 是一个二进制数，表示第 $i$ 行每个位置的状态。若 $j$ 的第 $k$ 位为 $0$，则表示第 $i$ 行第 $k$ 个格子是空闲的，否则表示是被覆盖的。

考虑如何计算 $f_{i,j}$。

如果当前这一行都是空闲的格子，则 $f_{i,j}=f_{i-1,j\oplus 2^M}$，其中 $\oplus$ 表示按位异或运算。

对于每一行，可以分类讨论当前行的状态对应的前一行状态的所有情况，即：

- 当前行和前一行的格子都是空闲的，则合法的状态只有 $00...0$，此时 $f_{i,j}=f_{i-1,0}$。
- 当前行和前一行的格子都被完全覆盖，则合法的状态只有 $11...1$，此时 $f_{i,j}=f_{i-1,2^M-1}$。
- 当前行和前一行的格子有一部分被覆盖，则状态的转移可以考虑上一行从哪些状态转移过来，假设这些状态为 $p$，则当前状态必须对应着这些状态的某个合法转移。在当前行中，只有每个空闲格子都被覆盖的时候才能进行转移，即当前状态中的 $0$ 必须出现在某个 $p$ 的 $1$ 上面。同时，由于每个 $1$ 可以覆盖两个 $0$，所以转移后的状态中的 $1$ 的数量不能超过 $M$。满足这些条件的所有 $p$ 对应的转移方案都是合法的，即：
$$f_{i,j}=\sum_{p\rightarrow j}f_{i-1,p}$$
其中 $\rightarrow$ 表示从 $p$ 转移到 $j$ 是合法的转移。

最终的答案是 $f_{N,0}$。

时间复杂度为 $O(N3^M)$，空间复杂度为 $O(2^M)$。可以通过本题。

#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

const int N=12,M=1<<N;

typedef long long LL;

int n,m;
LL f[N][M];
bool st[M];
vector<int> state[M];

int main()
{
    while(cin>>n>>m,n||m)
    {
        for(int i=0;i<1<<n;i++)
        {
            int cnt=0;
            bool is_valid=true;
            for(int j=0;j<n;j++)
            {
                if(i>>j&1)
                {
                    if(cnt&1)
                    {
                        is_valid=false;
                        break;
                    }
                    cnt=0;
                }
                else cnt++;
            }
            if(cnt&1) is_valid=false;
            st[i]=is_valid;
        }
        
        for(int i=0;i<1<<n;i++)
        {
            state[i].clear();
            for(int j=0;j<1<<n;j++)
            {
                if((i&j)==0&&st[i|j])
                {
                    state[i].push_back(j);
                }
            }
        }
        
        memset(f,0,sizeof f);
        f[0][0]=1;
        for(int i=1;i<=m;i++)
        {
            for(int j=0;j<1<<n;j++)
            {
                for(auto k:state[j])
                {
                    f[i][j]+=f[i-1][k];
                }
            }
        }
        
        cout<<f[m][0]<<endl;
    }
    
    return 0;
}