K皇后问题

     FZU比赛残留了一题搜索题 K Queen 没做, 题目大意就是在m*n的棋盘上布置k个皇后，使得这k个皇后互不攻击（这里的攻击含义同“八皇后问题”，即两个皇后不可以在同一行，同一列及同一斜线上)。其中1≤m*n≤150,1≤k≤50，时限10s
    
    其实从题目中我们可以推出一个很简单但是很重要的结论，即min(m, n) < 13， 言下之意就是说这个棋盘的较短的一边长度不会超过12，这样就不会对150这个数字感到恐惧了。同样，我们可以断言 k <= min(m, n)。另外一个简单的结论是
f[m][n][k] = f[n][m][k] (f[m][n][k]表示m*n的棋盘放置k个互不攻击的皇后种数)

    其次，我们可能想到直接回溯进行硬搜，那很不幸这样是行不通的。为什么行不通，很多相似的状态进行重复的搜索，我们需要把那些相似状态给去除掉，也就是要加上一个强力的剪枝才行。 不难发现，我们要处理的是一个棋盘，而棋盘具有某些对称的性质。通过利用这些性质我们可以有效的减少搜索空间，从而使得效率得到很大提升。（理论上说应该能减少1/4，我在使用过程中为了方便，减少了1/2)

   能否更快些呢？记得以前在群里头听讨论说n皇后有个超快的位运算版本，上网搜了搜，发现确实很强悍，如果配合上位运算再加上对称性，那是相当的完美了。(关于n皇后位运算版本的介绍可以参加matrix67的blog的 这篇文章)

   下面是AC的代码，6.2s

// 农夫三拳@seu
#include  < stdio.h >
#include  < string .h >

typedef  long   long  i64;


i64 s[ 151 ][ 151 ][ 51 ];
int  m, n, x, y;
int  MASK;
i64 ans;

void  dfs( int  m,  int  n,  int  row,  int  ld,  int  rd,  int  num,  int  p,  int  index)
{
    if(num == p)
        ans++;
    else if(index < m)
    {
        if(num + m - index > p)
            dfs(m, n, row, ld << 1, rd >> 1, num, p, index + 1);
        int pos = MASK & ~(row | rd | ld);
        while(pos != 0)
        {
            int pp = pos & -pos;
            pos = pos - pp;
            dfs(m, n, row + pp, (ld + pp) << 1, (rd + pp) >> 1, num + 1, p, index + 1);
        }
    }
}

i64 solve( int  m,  int  n,  int  p)
{
    if(s[m][n][p] != -1)
        return s[m][n][p];
    if(p > n)
        return 0;

    i64 ret = 0;
    int i, j;
    for(j = 0; j < n; j++)
    {
        int pos = 1 << (n - 1 - j);
        ans = 0;
        dfs(m, n, pos, pos << 1, pos >> 1, 1, p, 1); 
        ret += ans;
    }    

    s[m][n][p] = ret;

    return ret;
}

int  main()
{
    int i, j;
    memset(s, -1, sizeof(s));

    while(scanf("%d%d%d%d", &m, &n, &x, &y) == 4)
    {
        if(m < n && n > 31)
        {
            int t = m;
            m = n;
            n = t;
        }
        if(y > n)
            y = n;
        MASK = (1 << n) - 1;
        i64 res = 0;
        if(x == 0)
            res++, x = 1;
        for(i = x; i <= y; i++)
        {
            for(j = i; j <= m; j++)
                res += solve(j, n, i);
        }
        printf("%lld\n", res);
    }

    return 0;
}

后记:
1. 通过实验发现，当给定m*n(n > m)棋盘的时候，在n < 31的范围以内尽量使n较大，反之将m，n进行交换处理，这样可以充分的利用int范围内的位运算的效果。 其实当用64位的位运算之后，速度反而降下来了。
2. 如果利用一行的对称型，我们只要枚举第一个皇后在某行的列的一半就可以了