骑士

骑士

---

Description

国际象棋中骑士的移动规则和中国象棋中的马是类似的，它先沿着一个方向移动两格，再沿着与刚才移动方向垂直的方向移动一格。
路径上的棋子并不会影响骑士的移动，但是如果一个骑士走到了一个放有棋子的格子，它就会攻击那个棋子。
现在有一个 $n*n$ 的棋盘，有 $k$ 个骑士需要被摆到棋盘上去。
那么使所有骑士互不攻击的摆放方式一共有多少种呢？

---

Input

一行：两个整数，$n,k$。

---

Output

一行：一个整数，为摆放的方案数。

---

Sample Input 1

3 2

---

Sample Output 1

28

---

Sample Input 2

4 4

---

Sample Output 2

412

---

Data Size & Time limit

数据编号	数据范围	时间限制	单个测试点分值	总分值
1~15	$1\leq n\leq 4$	1.0s	3	45
16~20	$5\leq n\leq 6$	1.0s	5	25
21~25	$7\leq n\leq 8$	5.0s	6	30

对于所有的数据，$0<=k<=n^2$，保证答案不超过double的精度。

---

Solution

因为一个棋子所影响的范围只有两行，所以我们可以把每两行做成一个状态，然后dfs预处理出所有可行的状态，然后判断两两之间能否转移。
然后用dp即可求出答案。
需要注意的是，若 $n$ 为奇数，那么需要算到比 $n$ 小的最大的偶数，然后暴力计算最后一行的情况即可。
我竟然还用了组合数……

---

Code

#include <iostream>
#include <cstdio>

using namespace std;

int n,k,cnt;
int que[10000];
int ss[10000];
int jie[100000];

int head[10000],nxt[1000000],data[1000000];
bool already[1000000];

double f[5][100][10000],ans;

void dfs(int s1,int s2,int p,int sum){
    if(p==n){
        if(!already[(s1<<n)^s2]){
            already[(s1<<n)^s2]=true;
            que[++que[0]]=(s1<<n)^s2;
            ss[que[0]]=sum;
        }
        return;
    }
    else{
        dfs(s1<<1,s2<<1,p+1,sum);
        if(sum+1<=k){
            if(!(s1&2))dfs(s1<<1,(s2<<1)|1,p+1,sum+1);
            if(!(s2&2))dfs((s1<<1)|1,s2<<1,p+1,sum+1);
            if(sum+2<=k)if(!(s2&2)&&!(s1&2))dfs((s1<<1)|1,(s2<<1)|1,p+1,sum+2);
        }
    }
}

void add(int x,int y){
    nxt[cnt]=head[x];data[cnt]=y;head[x]=cnt++;
}

bool judge(int x,int y){
    for(int i=0;i<n;i++){
        if(i>=1){
            if((que[y]&(1<<(2*n-i-1)))&&(que[x]&(1<<(2*n-i))))return false;
            if((que[y]&(1<<(n-i-1)))&&(que[x]&(1<<(n-i))))return false;
        }
        if(i<n-1){
            if((que[y]&(1<<(2*n-i-1)))&&(que[x]&(1<<(2*n-i-2))))return false;
            if((que[y]&(1<<(n-i-1)))&&(que[x]&(1<<(n-i-2))))return false;
        }
        if(i>=2)
            if((que[y]&(1<<(2*n-i-1)))&&(que[x]&(1<<(n-i+1))))return false;
        if(i<n-2)
            if((que[y]&(1<<(2*n-i-1)))&&(que[x]&(1<<(n-i-3))))return false;
    }
    return true;
}

void work(){
    jie[0]=1;
    int maxn=(n*n>k*k?n*n:k*k);
    for(int i=1;i<=maxn;i++)jie[i]=jie[i-1]*i;
}

double C(int tot,int xd){
    return jie[tot]/jie[xd]/jie[tot-xd];
}

double done(int xd,int ll){
    int tot=n;
    if(xd>n)return 0;
    for(int i=0;i<n;i++){
        if(i>=1&&(que[ll]&(1<<(2*n-i))))tot--;
        else if(i<n-1&&(que[ll]&(1<<(2*n-i-2))))tot--;
        else if(i>=2&&(que[ll]&(1<<(n-i+1))))tot--;
        else if(i<=n-2&&(que[ll]&(1<<(n-i-3))))tot--;
        if(xd>tot)return 0;
    }
    return C(tot,xd);
}

double get_ans(int x){
    double tmp=0;
    for(int j=0;j<=k;j++)
        tmp+=f[n>>1][k-j][x]*done(j,x);
    return tmp;
}

int main(){

    freopen("knight.in","r",stdin);
#ifndef DEBUG
    freopen("knight.out","w",stdout);
#endif

    memset(head,-1,sizeof head);

    scanf("%d%d",&n,&k);
    dfs(0,0,0,0);

    if(n==1){
        printf("%d\n",(k==1||k==0)?1:0);
        return 0;
    }

    else{
        for(int i=1;i<=que[0];i++)
            for(int j=1;j<=que[0];j++)
                if(judge(i,j))
                    add(i,j);

        for(int l=1;l<=que[0];l++)
            f[1][ss[l]][l]=1;

        int limit=n>>1;

        for(int i=1;i<limit;i++)
            for(int j=0;j<=k;j++)
                for(int l=1;l<=que[0];l++)if(ss[l]<=j&&f[i][j][l])
                    for(int x=head[l];x!=-1;x=nxt[x])
                        if(j+ss[data[x]]<=k)
                            f[i+1][j+ss[data[x]]][data[x]]+=f[i][j][l];

        if((limit<<1)!=n)work();

        if((limit<<1)==n)for(int l=0;l<=que[0];l++)ans+=f[limit][k][l];
        else for(int l=0;l<=que[0];l++)ans+=get_ans(l);

        printf("%.0lf\n",ans);
    }
    return 0;
}