N皇后问题 各种优化

0.问题引入

 N皇后问题是一个经典的问题，在一个N*N的棋盘上放置N个皇后，每行一个并使其不能互相攻击（同一行、同一列、同一斜线上的皇后都会自动攻击），问有多少种摆法。

题目链接：https://www.luogu.org/problemnew/show/P1219

1、普通回溯

回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。

算法思想：

1. 在第k（1≤k≤N）行选择一个位置，判断这个位置是否可以摆，可以摆就进入第 k+1 行，不可以就试下一个位置；

2. 如果一直试到本行最后一个都不行，说明前面k-1行有位置选得不恰当，回到第 k-1 行，试 k-1 行的下一个位置。

3. 反复执行1,2，到最后一行摆上棋子时，说明找到了一个解。

一个问题能用回溯法求解，它的解具有$N$元组的形式，我们使用用$N$元组$(x_1,x_2,...,x_n)$表示问题的解，其中$x_i$表示第$i$行的皇后所处的列号。

核心代码：

//row,col表示当前尝试摆放皇后的行号与列好
bool check(int row, int col) {
    for (int i = 1; i < row; i++) {
        if (x[i] == col)//列冲突
            return false;
        if (abs(row - i) == abs(col - x[i]))//对角线冲突
            return false;
    }
    return true;
}
void DFS(int k) {
    if (k == N + 1) {
        //获得了一个解
        cnt++;
        return;
    }
    for (int i = 1; i <= N; i++) {
        if (check(k, i)) {
            x[k] = i;//标注第k行上第i个位置摆上了皇后
            DFS(k + 1);
        }
    }
}

1.1 递归实现：

N=11,12的时就顶不住了，嗝屁了。

#include <iostream>
#include <math.h>
using namespace std;

int x[15];
int N, cnt;

bool check(int row, int col) {
    //回溯，不会受到后面行的影响
    for (int i = 1; i < row; i++) {
        if (x[i] == col)return false;
        if (abs(row - i) == abs(col - x[i]))return false;
    }
    return true;
}
void DFS(int k) {
    if (k == N + 1) {
        cnt++;
        if (cnt <= 3) {
            for (int i = 1; i <= N; i++) {
                cout << x[i] << " ";
            }
            cout << endl;
        }
        return;
    }
    for (int i = 1; i <= N; i++) {
        if (check(k, i)) {
            x[k] = i;
            DFS(k + 1);
        }
    }
}

int main() {
    cin >> N;
    DFS(1);
    cout << cnt << endl;
    return 0;
}

1.2 非递归实现：

算法优化一般不从这里考虑，因为非递归虽然是会快一点，但也只是那么一点而已，数据量小几乎没有区别，两个都跑不过去。

#include <iostream>
#include <math.h>
using namespace std;

int x[15];
int N, cnt;

bool check(int row, int col) {
    //回溯，不会受到后面行的影响
    for (int i = 1; i < row; i++) {
        if (x[i] == col)return false;
        if (abs(row - i) == abs(col - x[i]))return false;
    }
    return true;
}


void queen(){
    //i表示第几册，j表示在第i层搜索位置
    int i = 1, j = 1;
    while (i <= N){
        while (j <= N){
            //如果当前位置合法
            if (check(i, j)) {
                //把x[i]暂时赋值成j
                x[i] = j;
                j = 1;
                break;
            }
            else
                j++;
        }
        //第i行没有找到可以放置皇后的位置
        if (x[i] == 0){
            //如果回溯到了第0行，说明完成了         
            if (i == 1)
                break;
            //回溯
            else{
                i--;
                j = x[i] + 1;//j为上一行的皇后位置+1
                x[i] = 0;//上一行清零
                continue;
            }
        }
        //如果找到了第N层，输出出来
        if (i == N){
            cnt++;
            if (cnt <= 3) {
                for (int i = 1; i <= N; i++) {
                    cout << x[i] << " ";
                }
                cout << endl;
            }
            j = x[i] + 1; 
            x[i] = 0;     
            continue;
        }
        i++;              
    }
}
int main() {
    cin >> N;
    //DFS(1);
    queen();
    cout << cnt << endl;
    return 0;
}

 

2、减半优化

其实仔细看解就不难发现，每个结果总有另一个与之对称。我们可以利用棋盘的对称, 只用回溯一半 。效率能提升50%。

对于第一层，只下该行的前一半的位置即可。但是对于奇数的N，计算出来的结果会将第一行下在中间位置的解算了两遍。所以要单独处理一下。

效率提升不到50%（奇数的情况），并不算多，题目的测试数据只到13，勉强跑过了，但优化还没结束。

#include <iostream>
#include <vector>
#include <math.h>
using namespace std;

int x[15];
vector<int> v[3];
int N, cnt;
int flag, oddCnt;

bool check(int row, int col) {
    //回溯，不会受到后面行的影响
    for (int i = 1; i < row; i++) {
        if (x[i] == col)return false;
        if (abs(row - i) == abs(col - x[i]))return false;
    }
    return true;
}
void DFS(int k) {
    if (k == N + 1) {
        if (flag&&x[1] == (N + 1) / 2) {
            oddCnt++;
            if (oddCnt % 2 == 0)cnt++;
        }
        else
        cnt++;
        if (cnt <= 3) {
            for (int i = 1; i <= N; i++) {
                cout << x[i] << " ";
                v[cnt - 1].push_back(x[i]);
            }
            cout << endl;
        }
        return;
    }
    int len = (k == 1) ? (N + flag) / 2 : N;
    for (int i = 1; i <= len; i++) {
        if (check(k, i)) {
            x[k] = i;
            DFS(k + 1);
        }
    }
}

int main() {
    cin >> N;
    if (N & 1)flag = 1;
    DFS(1);
    for (int i = cnt, j = cnt - 1; i < 3 && j >= 0; i++, j--) {
            for (int k = N - 1; k >= 0; k--) {
                cout << v[j][k] << " ";
            }
            cout << endl;
        }
    
    cout << cnt*2 << endl;
    return 0;
}

 

3、优化判断

以本图为例：

每条橙色对角线的行列之差是相同的。

每条蓝色对角线的行列之和是相同的。

用两个bool数组用来记录行列之和为 i 的正斜线、行列之差为 i 的反斜线是否已经被占据。考虑到行列之差可能为负数，棋盘坐标 [x,y] 对应下标 [ x - y + n ]。

再用一个数组记录第 i 列是否有元素。

#include <iostream>
using namespace std;

int N, cnt,a[15];
//正对角线、副对角线、行
bool x1[31], x2[31], y[15];

void DFS(int k) {
    if (k == N + 1) {
        cnt++;
        if (cnt <= 3) {
            for (int i = 1; i <= N; i++) {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        return;
    }
    for (int i = 1; i <= N; i++) {
        //这里x2下标不能用abs，那样是不对的
        if (!x1[i + k] && !x2[k - i + N] && !y[i]) {
            a[k] = i;
            x1[i + k] = 1;
            x2[k - i + N] = 1;
            y[i] = 1;
            DFS(k + 1);
            x1[i + k] = 0;
            x2[k - i + N] = 0;
            y[i] = 0;
        }
    }
}


int main() {
    cin >> N;
    DFS(1);
    cout << cnt << endl;
    return 0;
}

当N较大时，算法会耗费大量的次数在无用的回溯上，时间还是没有显著提高。

4、位运算优化

警告:以下代码可能引起不适，请60岁以下用户在家长陪同下阅读。

位运算是计算机最快的操作，我们可以用数的二进制位表示各纵列、对角线是否可以放置皇后。

看讲解的：https://blog.csdn.net/Hackbuteer1/article/details/6657109 博主讲的很清楚了。

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

int n, limit, cnt;
int x[15], k = 1;
//行，左对角线，右对角线
void DFS(int row,int left,int right) {
    if (row != limit) {
        //row|left|right表示这一行的所有禁止位置，取反再和limit按位与，得到的是该行可以放的几个位置        
        int pos = limit & ~(row | left | right);
        //每一个可以摆的位置，都要做一次
        while (pos) {
            //找到的可以放皇后的位置（pos二进制最右边的一个1）
            int p = pos & -pos;// pos & (~pos+1);
            //把这一位置0，表示不为空
            pos &= pos - 1;//pos=pos-p;
            //把p所在row，left，right的位都置1。
            //(left | p)<< 1 是因为这一行由左对角线造成的禁止位在下一行要右移一下；right同理
            DFS(row | p, (left | p) << 1, (right | p) >> 1);
        }
    }
    else {
        cnt++;
    }
}

int main() {
    cin >> n;
    limit = (1 << n) - 1;
    DFS(0, 0, 0);
    cout << cnt << endl;
    return 0;
}

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

int n, limit, cnt;
int x[15], k = 1;
//行，左对角线，右对角线
void DFS(int row,int left,int right) {
    if (row != limit) {
        int pos = limit & ~(row | left | right);
        while (pos) {
            //找到的可以放皇后的位置
            int p = pos & -pos;// pos & (~pos+1);
            pos &= pos - 1;
            if (cnt < 3) {
                int t = p, num = 1;
                while (t != 1) {
                    num++;
                    t >>= 1;
                }
                x[k++] = num;
            }
            DFS(row | p, (left | p) << 1, (right | p) >> 1);
            if (cnt < 3) k--;
        }
    }
    else {
        if (cnt < 3) {
            for (int i = 1; i <= n; i++) {
                cout << x[i] << " ";
            }
            cout << endl;
        }
        cnt++;
    }
}

int main() {
    cin >> n;
    limit = (1 << n) - 1;
    DFS(0, 0, 0);
    cout << cnt << endl;
    return 0;
}

果然名不虚传~