状态压缩DP

总结状压DP转移的方法：
若某个状态下可以对下

玉米田（十字形）

1.按二进制读入数据
2.枚举所有方案，如果合理（一行中没有两两相邻的）就存储 i & (i << 1)
3.因为每一层的状态只受上一层影响，因此循环两次所有合理方案，为每一个方案找到一系列下一层合理方案
4.遍历每一行，并遍历每一行的所有合理方案，若与预处理不矛盾，继续遍历其下一行的所有合理方案，将情况累加。

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

using namespace std;

const int N = 14 , M = 1 << 12 , P = 1e8;

vector<int> head[M];//每个状态可以转移到的其他转态
vector<int> state;
int n , m;//n是行 ，m是列 
int f[N][M];//f[i][j]表示已经摆完前i行，第i行的转态是j
int w[N];//给定的图



int main()
{
    cin >> n >> m;
    for(int i = 1 ; i <= n ; i++)//1.按二进制读入数据
        for(int j = 0 ; j < m ; j++)
        {
            int t ;
            cin >> t;
            w[i] += !t << j;
        }
        
    for(int i = 0 ; i < 1 << m ; i++)//2.枚举所有方案，如果合理（一行中没有两两相邻的）就推入
        if(!(i & (i << 1))) state.push_back(i);
        
    for(int i = 0 ; i < state.size() ; i++)    //3.因为每一层的状态只受上一层影响，因此循环两次所有合理方案，为每一个
        for(int j = 0 ; j < state.size() ; j++)//方案找到一系列下一层合理方案
        {
            int a = state[i] , b = state[j];
            if(!(a & b))
            head[i].push_back(j);//将j方案归在i下
        }
    
    f[0][0] = 1;//小技巧：这里截止到n+1，就省去最后的累加
    for(int i = 1 ; i <= n + 1 ; i++)          //4.遍历每一行，并遍历每一行的所有合理方案，若与预处理不矛盾，就遍历
        for(int j = 0 ; j < state.size() ; j++)//其下一行的所有合理方案，将情况累加。
            if(!(state[j] & w[i])) 
            for(int a : head[j])
            f[i][j] = (f[i][j] + f[i - 1][a]) % P;
    
    cout << f[n + 1][0] << endl;
        
    return 0;
}

骑士（井字形）

1.枚举所有方案，如果合理（一行中没有两两相邻的）就存储 i & (i << 1)
2.因为每一层的状态只受上一层影响，因此循环两次所有合理方案，为每一个方案找到一系列下一层合理方案
3.遍历每一行，并遍历每一种国王的个数，并遍历每一行的所有合理方案，若与预处理不矛盾，继续遍历其下一行的所有合理方案，若改方案下国王个数小于当前循环内限制的国王个数，则将情况累加。

#include <iostream>
#include <vector>

using namespace std;

const int N = 12 , K = 110 , M = 1 << 11;

long long f[N][K][M];
int n , m;
int cnt[M];
vector<int> head[M] , state;

int count(int a)
{
    int ans = 0;
    do ans += a & 1 ; while(a >>= 1);
    return ans;
}

int check(int a)
{
    return !(a & a << 1);
}

int main()
{
    cin >> n >> m;
    
    for(int i = 0 ; i < 1 << n ; i++)
        if(check(i))
        {
            state.push_back(i);
            cnt[i] = count(i);
        }
        
    for(int i = 0 ; i < state.size() ; i++)
        for(int j = 0 ; j < state.size() ; j++)
        {
            int a = state[i] , b = state[j];
            if(!(a & b) && check(a | b))
                head[i].push_back(j);
        }
    
    f[0][0][0] = 1; //初始化不能忘！！！！！   
    for(int i = 1 ; i <= n + 1 ; i++)
        for(int j = 0 ; j <= m ; j++)
            for(int a = 0 ; a < state.size() ; a++)
                for(int b : head[a])
                {
                    int c = cnt[state[a]];
                    if(c <= j)
                    f[i][j][a] += f[i - 1][j - c][b];
                }
    
    cout << f[n + 1][m][0] << endl;
    return 0;
}