挑战程序设计(算法和数据结构)—八皇后问题总结

一道八皇后问题相关问题

题目19.1链接8 Queens Problem
这道题给出已有几个皇后放置的位置，然后让你补全剩下的位置。
自己的方法:
我的方法实际上就是维护一个棋盘矩阵，值为0时可以放置，为-1时表示该位置是皇后，大于0时不可放置，每当放置一个皇后时就要将皇后可以到达的地点+1，当去除一个皇后时需要将皇后可以到达的地点-1。当然我使用了栈来记录已放置的皇后的位置，当放置完最后一行时，跳出循环。
代码如下：

#include <iostream>
#include <cstring>
#include <stack>
#include <set>
using namespace std;

struct Node
{
    int r, c;
    Node(int r=-1, int c=-1): r(r), c(c){}
};
const int MAX = 8;
int k, sr, sc;
int G[MAX][MAX];//0代表可以放置，-1代表是皇后，正数代表不能放
set<int> R;

void load(Node u)//放置u位置后，更新矩阵
{
    int r = u.r, c = u.c;
    for(int i=0; i<MAX; i++)//竖
    {
        if(G[i][u.c]!=-1) G[i][u.c]++;
    }
    for(int j=0; j<MAX; j++)//橫
    {
        if(G[u.r][j]!=-1) G[u.r][j]++;
    }
    for(int t=1; u.r-t>=0 && u.c-t>=0; t++)//左上
    {
        if(G[u.r-t][u.c-t]!=-1) G[u.r-t][u.c-t]++;
    }
    for(int t=1; u.r+t<MAX && u.c+t<MAX; t++)//右下
    {
        if(G[u.r+t][u.c+t]!=-1) G[u.r+t][u.c+t]++;
    }
    for(int t=1; u.r+t<MAX && u.c-t>=0; t++)//左下
    {
        if(G[u.r+t][u.c-t]!=-1) G[u.r+t][u.c-t]++;
    }
    for(int t=1; u.r-t>=0 && u.c+t<MAX; t++)//左上
    {
        if(G[u.r-t][u.c+t]!=-1) G[u.r-t][u.c+t]++;
    }
    return;
}

void unload(Node u)//去掉u位置后，更新矩阵
{
    int r = u.r, c = u.c;

    for(int i=0; i<MAX; i++)//竖
    {
        if(G[i][u.c]!=-1) G[i][u.c]--;
    }
    for(int j=0; j<MAX; j++)//橫
    {
        if(G[u.r][j]!=-1) G[u.r][j]--;
    }
    for(int t=1; u.r-t>=0 && u.c-t>=0; t++)//左上
    {
        if(G[u.r-t][u.c-t]!=-1) G[u.r-t][u.c-t]--;
    }

    for(int t=1; u.r+t<MAX && u.c+t<MAX; t++)//右下
    {
        if(G[u.r+t][u.c+t]!=-1) G[u.r+t][u.c+t]--;
    }
    for(int t=1; u.r+t<MAX && u.c-t>=0; t++)//左下
    {
        if(G[u.r+t][u.c-t]!=-1) G[u.r+t][u.c-t]--;
    }
    for(int t=1; u.r-t>=0 && u.c+t<MAX; t++)//左上
    {
        if(G[u.r-t][u.c+t]!=-1) G[u.r-t][u.c+t]--;
    }
    G[r][c] = 0;
    return;
}
void solve()
{
    stack<Node> S;//记录已放置的位置
    S.push(Node(-1, -1));//初始放入一个位置，利于以下循环
    int v = -1;//上一次该行放置的皇后的列
    while(1)
    {
        Node u = S.top();//最新放入的位置
        int i=u.r+1, flag=1;
        while(R.count(i)) i++;//寻找下一个空行
        if(i==MAX) break;//超出范围，证明已放完
        for(int j=v+1; j<MAX; j++)
        {
            if(G[i][j]==0)//可以放置
            {
                G[i][j] = -1;
                S.push(Node(i, j));
                flag = 0;
                v = -1;
                load(Node(i, j));
                break;
            }
        }
        if(flag)//如果当前行没有合适的位置
        {
            S.pop();
            v = u.c;
            unload(u);
        }
        else if(i==MAX-1)//如果最后一行放完
        {
            break;
        }
    }
}
void print()
{
    for(int i=0; i<MAX; i++)
    {
        for(int j=0; j<MAX; j++)
        {
            if(G[i][j]==-1)
                cout << "Q";
            else
                cout << ".";
        }
        cout << endl;
    }
}
int main()
{
    cin >> k;
    memset(G, 0, sizeof(G));//
    for(int i=0; i<k; i++)
    {
        cin >> sr >> sc;
        G[sr][sc] = -1;
        load(Node(sr, sc));
        R.insert(sr);
    }
    solve();
    print();
    return 0;
}

书上的方法：
变量设置如下：

变量	含义
row[N]	如果row[x]为NOT_FREE，则x行受到攻击
col[N]	如果col[x]为NOT_FREE，则x列受到攻击
dpos[2*N-1]	如果dpos[N]为NOT_FREE，则斜向左下的x列受到攻击
dneg[2*N-1]	如果dneg[N]为NOT_FREE，则斜向右下的x列受到攻击

思路：只要row[i]、col[j]、dpos[i+j]、dneg[i-j+N-1]（为了保证下标为非负，需要加上N-1）中任意一个为NOT_FREE时，格子（i,j）会受到攻击。
技巧：主对角线坐标相减，负对角线坐标相加。
求出所有的八皇后的解，如果满足输入条件，则输出结果，否则回溯继续求解。
代码如下：

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

const int N = 8;
const int FREE = -1;
const int NOT_FREE = 1;

int row[N], col[N], dpos[2*N-1], dneg[2*N-1];
int G[N][N];

void printBoard()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            if(G[i][j] && row[i]!=j)//判断此时的八皇后是否满足输入条件
                return;
        }
    }
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            if(row[i]==j)
                cout << "Q";
            else
                cout << ".";
        }
        cout << endl;
    }
}
void recursive(int i)
{
    if(i==N)
    {
        printBoard();

        return;
    }

    for(int j=0; j<N; j++)//八皇后问题的解法，递归回溯求出八皇后的解，但只有一个接满足输入条件，在printBoard里判断
    {
        if(col[j]==NOT_FREE || dpos[i+j]==NOT_FREE || dneg[i-j+N-1]==NOT_FREE)
            continue;
        row[i] = j;因为按行递归所以不会有行冲突，用行来记录皇后放置的位置
        col[j] = dpos[i+j] = dneg[i-j+N-1] = NOT_FREE;
        recursive(i+1);

        row[i] = col[j] = dpos[i+j] = dneg[i-j+N-1] = FREE;
    }
}

int main()
{
    int k, sr, sc;
    cin >> k;
    memset(row, FREE, sizeof(row));
    memset(col, FREE, sizeof(col));
    memset(dpos, FREE, sizeof(dpos));
    memset(dneg, FREE, sizeof(dneg));
    memset(G, 0, sizeof(G));
    for(int i=0; i<k; i++)
    {
        cin >> sr >> sc;
        G[sr][sc] = 1;
    }
    recursive(0);
    return 0;
}

八皇后解法总结

四种解法：八皇后问题详解(四种解法)