【ACWing】1064. 小国王

题目地址：

https://www.acwing.com/problem/content/1066/

在$n\times n$的棋盘上放$k$个国王，国王可攻击相邻的$8$个格子，求使它们无法互相攻击的方案总数。

输入格式：
共一行，包含两个整数$n$和$k$。

输出格式：
共一行，表示方案总数，若不能够放置则输出$0$。

数据范围：
$1\le n\le 10$
$0\le k\le n^2$

思路是动态规划，可以用状态压缩来存每行的国王摆放情况，即用一个整数的二进制位来表达某个位置是否摆放了国王。接着，令$f[i][j][s]$表示当前在摆第$i$行，总共摆放了$j$个国王（包括第$i$行本身的国王），并且摆放成$k$的二进制表示这个样子的方案数。那么最终就是要求$$\sum _{s=0}^{2^n-1}f[n][k][s]$$初始条件$f[0][0][0]=1$，表示什么都没摆的情况。对于其它情形，我们可以根据第$i-1$行的摆放情况来分类，则有：$$f[i][j][s]=\sum _{p\to s}f[i-1][j-c(s)][p]$$其中$c(s)$表示$s$里的$1$的个数，$p\to s$的意思是如果第$i-1$行摆放的情况是$p$，那么第$i$行可以摆放为$s$，也就是这两个行是不产生矛盾的。接下来考虑怎么样的两个状态是不矛盾的。如果$p\&s=1$或者$p|s$有两个连续的$1$，那么就矛盾了，前者表示有两个国王在同一列相邻的两行，后者表示下一行某个国王的左上或者右上有国王。除此之外都是可以的。为了加速，我们可以预处理出来所有状态的$1$的个数，以及某个状态$s$对应的$p$。代码如下：

#include <iostream>
#include <vector>
using namespace std;

const int N = 11, M = 1 << 10, K = 110;
int n, k;
// 存某行可以放的国王合法状态（即没有两个连续的1）
vector<int> state;
// 存每个数的二进制表示里1的个数
int cnt[M];
// head[i]存哪些状态与i这个状态不矛盾
vector<int> head[M];
// 答案比较大，要用long来存
long f[N][K][M];

// 判断st是否不含两个连续的1，如果不含，就返回true，否则返回false
bool check(int st) {
    for (int i = 0; i < n; i++)
        if ((st >> i & 1) && (st >> i + 1 & 1))
            return false;
    return true;
}

// 返回st二进制里1的个数
int count(int st) {
    int cnt = 0;
    while (st) {
        st -= st & -st;
        cnt++;
    }
    return cnt;
}

int main() {
    cin >> n >> k;
    // 求一下合法状态，并且将它们的1的个数存下来
    for (int i = 0; i < 1 << n; i++)
        if (check(i)) {
            state.push_back(i);
            cnt[i] = count(i);
        }
	
	// 求一下对每个状态i，哪些状态j与之不矛盾
    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) == 0 && check(a | b))
                head[i].push_back(j);
        }
	
    f[0][0][0] = 1;
    // 枚举摆放到第几行
    for (int i = 1; i <= n; i++)
    	// 枚举一共摆多少个国王
        for (int j = 0; j <= k; j++)
        	// 枚举当前行可以摆放的状态
            for (int cu = 0; cu < state.size(); cu++)
            	// 枚举第i - 1行可以摆放的状态
                for (int pr : head[cu]) {
                    int c = cnt[state[cu]];
                    if (c <= j) f[i][j][cu] += f[i - 1][j - c][pr];
                }

    long res = 0;
    for (int i = 0; i < state.size(); i++) res += f[n][k][i];

    cout << res << endl;

    return 0;
}

时间复杂度$O(nk{2}^{2n})$，但是实际的复杂度没有那么高，因为行合法的状态数是远小于$2^n$个的，空间$O(nk{2}^n)$。