2754 八皇后

问题描述：http://poj.grids.cn/practice/2754/

2754 - 八皇后

Time Limit:
1000ms
Memory limit:
65536kB

题目描述
会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。
如何将8个皇后放在棋盘上（有8 * 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。
对于某个满足要求的8皇后的摆放方法，定义一个皇后串a与之对应，即a=b1b2...b8，其中bi为相应摆法中第i行皇后所处的列数。
已经知道8皇后问题一共有92组解（即92个不同的皇后串）。给出一个数b，要求输出第b个串。
串的比较是这样的：皇后串x置于皇后串y之前，当且仅当将x视为整数时比y小。

输入
第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数b(1 <= b <= 92)

输出
输出有n行，每行输出对应一个输入。输出应是一个正整数，是对应于b的皇后串。
样例输入

2
1
92

样例输出

15863724
84136275 

首先是用了迭代法，把八层循环都列了出来。。 循环太多了，各种复制粘贴和查找替换。。最后内存252kb，时间0ms

/********************************************************************************************************
解题思路：

经典方法用的是递归和回溯，穷举所有情况。我用了八层的迭代来试试，主要要找一个高效的，
判定当前棋子是否能够安全放置的方法，并且拿掉此棋子还能够还原它对其他棋子的影响。

按照每行来迭代，自然不考虑行的限制。

用一个标识数组column[8]来判断当前列是否能够放棋子，并且保存受到了几个棋子的影响，
如果受到多个棋子影响了，回溯时拿掉一个棋子，不会影响其他棋子的影响。

用另2个标识数组diagonal_1[15]和diagonal_2[15]来判断当前右斜线和左斜线分别能否放棋子。
对于棋子board[i][j]，所在右斜线用diagonal_1[j-i+7]表示，左斜线用diagonal_2[i+j]表示。

内存：252kB
时间：0ms
********************************************************************************************************/

#include <iostream>
#include <cmath>
#include <cctype>
#include <string>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <list>
#include <stack>
#include <cstring>
//#include <stdlib.h>
//#include <iomanip>

using namespace std;

inline void add_chess(unsigned column[], unsigned diagonal_1[], unsigned diagonal_2[], int i, int j)
{
    column[j]++;
    diagonal_1[j-i+7]++;
    diagonal_2[i+j]++;
}

inline void cancel_chess(unsigned column[], unsigned diagonal_1[], unsigned diagonal_2[], int i, int j)
{
    column[j]--;
    diagonal_1[j-i+7]--;
    diagonal_2[i+j]--;
}

int main()
{
    //存放所有结果
    unsigned answers[92][8];
    //存放一次结果
    unsigned count = 0, hang[8] = {0};

    //用来记录当前的列是否可以放棋子
    unsigned column[8] = {0};
    unsigned diagonal_1[15] = {0}, diagonal_2[15] = {0};

    //////////////////////////////////////////////////////////////////////////
    //枚举所有情况，并且剪枝+回溯
    //第0层循环
    for (hang[0] = 0; hang[0] < 8; hang[0]++)
    {
        add_chess(column, diagonal_1, diagonal_2, 0, hang[0]);
        //第1层循环
        for (hang[1] = 0; hang[1] < 8; hang[1]++)
        {
            if (column[hang[1]] == 0 && diagonal_1[hang[1]+6] == 0 && diagonal_2[hang[1]+1] == 0)
            {
                add_chess(column, diagonal_1, diagonal_2, 1, hang[1]);
                //第2层循环
                for (hang[2] = 0; hang[2] < 8; hang[2]++)
                {
                    if (column[hang[2]] == 0 && diagonal_1[hang[2]+5] == 0 && diagonal_2[hang[2]+2] == 0)
                    {
                        add_chess(column, diagonal_1, diagonal_2, 2, hang[2]);
                        //第3层循环
                        for (hang[3] = 0; hang[3] < 8; hang[3]++)
                        {
                            if (column[hang[3]] == 0 && diagonal_1[hang[3]+4] == 0 && diagonal_2[hang[3]+3] == 0)
                            {
                                add_chess(column, diagonal_1, diagonal_2, 3, hang[3]);
                                //第4层循环
                                for (hang[4] = 0; hang[4] < 8; hang[4]++)
                                {
                                    if (column[hang[4]] == 0 && diagonal_1[hang[4]+3] == 0 && diagonal_2[hang[4]+4] == 0)
                                    {
                                        add_chess(column, diagonal_1, diagonal_2, 4, hang[4]);
                                        //第5层循环
                                        for (hang[5] = 0; hang[5] < 8; hang[5]++)
                                        {
                                            if (column[hang[5]] == 0 && diagonal_1[hang[5]+2] == 0 && diagonal_2[hang[5]+5] == 0)
                                            {
                                                add_chess(column, diagonal_1, diagonal_2, 5, hang[5]);
                                                //第6层循环
                                                for (hang[6] = 0; hang[6] < 8; hang[6]++)
                                                {
                                                    if (column[hang[6]] == 0 && diagonal_1[hang[6]+1] == 0 && diagonal_2[hang[6]+6] == 0)
                                                    {
                                                        add_chess(column, diagonal_1, diagonal_2, 6, hang[6]);
                                                        //第7层循环
                                                        for (hang[7] = 0; hang[7] < 8; hang[7]++)
                                                        {
                                                            if (column[hang[7]] == 0 && diagonal_1[hang[7]] == 0 && diagonal_2[hang[7]+7] == 0)
                                                            {
                                                                //添加一组解
                                                                memcpy(answers[count], hang, sizeof(unsigned)*8);
                                                                count++;
                                                            }
                                                        }
                                                        cancel_chess(column, diagonal_1, diagonal_2, 6, hang[6]);
                                                    }
                                                }
                                                cancel_chess(column, diagonal_1, diagonal_2, 5, hang[5]);
                                            }
                                        }
                                        cancel_chess(column, diagonal_1, diagonal_2, 4, hang[4]);
                                    }
                                }
                                cancel_chess(column, diagonal_1, diagonal_2, 3, hang[3]);
                            }
                        }
                        cancel_chess(column, diagonal_1, diagonal_2, 2, hang[2]);
                    }
                }
                cancel_chess(column, diagonal_1, diagonal_2, 1, hang[1]);
            }
        }
        cancel_chess(column, diagonal_1, diagonal_2, 0, hang[0]);
    }

    //////////////////////////////////////////////////////////////////////////
    //输入结果
    int n, tmp;
    cin >> n;
    while (n--)
    {
        cin >> tmp;
        for (int i = 0; i < 8; i++)
            cout << answers[tmp-1][i]+1;
        cout << "\n";
    }

    return 0;
}

然后用了经典的递归和回溯的方法，深度优先搜索一个八叉树。最后内存256kb，时间0ms

#include <iostream>
#include <cmath>
#include <cctype>
#include <string>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <list>
#include <stack>
#include <cstring>
//#include <stdlib.h>
//#include <iomanip>

using namespace std;

//用来记录当前的列是否可以放棋子
unsigned column[8] = {0};
unsigned diagonal_1[15] = {0}, diagonal_2[15] = {0};

//存放所有结果
unsigned answers[92][8];

//hang存放一次结果，count记录结果个数
unsigned ans_count = 0, hang[8] = {0};

inline void add_chess(int i, int j)
{
    column[j]++;
    diagonal_1[j-i+7]++;
    diagonal_2[i+j]++;
}

//i, j分别是行和列
inline void cancel_chess(int i, int j)
{
    column[j]--;
    diagonal_1[j-i+7]--;
    diagonal_2[i+j]--;
}

inline bool judge(int i, int j)
{
    if (column[j] == 0 && diagonal_1[j-i+7] == 0 && diagonal_2[i+j] == 0)
        return true;
    return false;
}

void putQueen(int ith_row)
{
    //则产生了一组新解，也即树的一条路径
    if (ith_row == 8)
    {
        memcpy(answers[ans_count], hang, sizeof(unsigned)*8);
        ans_count++;
    }
    //则查找当前行的8个棋盘格，如果可以放棋子，就放一个并且进行记录，标记对其它棋子的影响
    //并且往下深度递归，递归完，回溯到这一处时，还要取消对其它棋子的影响标记
    for (int j = 0; j < 8; j++)
    {
        if (judge(ith_row, j))
        {
            hang[ith_row] = j;
            add_chess(ith_row, j);
            putQueen(ith_row+1);
            cancel_chess(ith_row, j);
        }
    }
}

int main()
{
    //递归所有情况，并且剪枝+回溯
    putQueen(0);

    //输入结果
    int n, tmp;
    cin >> n;
    while (n--)
    {
        cin >> tmp;
        for (int i = 0; i < 8; i++)
            cout << answers[tmp-1][i]+1;
        cout << "\n";
    }

    return 0;
}