笔试题64. LeetCode OJ (51)

相信学习过算法的人都知道“N后”问题，今天我再次遇到了N后问题，之前确实只是知道算法思想，从来没想到到能自己实现“n后”问题，不过就在今天我实现了以前未达到的一个目标！

“n后”问题就是在一个 N*N 的方格中放入n个皇后，但是皇后可不是一般人，她比较刁蛮任性，只要是和她在一条线上（包括水平方向和竖直方向）的所有人她都攻击，不仅如此连在她斜线上的也不放过，所以我们这些程序员没有办法，只有设计出一种让所有皇后都满意的方法，让她们都满意，为了说明竞争的残酷，我将n后的攻击范围画出来了…

这道题要求出所有解，我们知道，只要我们求出了一个解的话，那么它必定布置一个解，想象一下，n后问题的解所在位置不是对称的(n后问题的条件限制)，所以你将正方形旋转360度之内肯定是有一个不同的解的，这就可以说明n后问题一般不止一个解(前提是有解的情况下)，当然我们是用程序控制的，不管他有多少解了，我们是不会漏过任何解的！

下面就请看代码吧：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n)
    {
        /* N后问题是每个位置的皇后会攻击它的横向的，纵向的以及斜线上的皇后 */
        vector<vector<string>> ret;
        ret.clear();
        vector<string> oneSolve;
        oneSolve.clear();
        for (int i = 0; i < n; ++i)
        {
            string tmp(n,'.');
            oneSolve.push_back(tmp);
        }

        _solves(ret, oneSolve, n, 0);
        return ret;
    }

    void _solves(vector<vector<string>>&ret, vector<string> oneSolve, int n,int index)
    {
        if (index == n)
        { 
            /* 其实这里不需要检查了，能进来的都是合格的，因为提前检测过了 if (_testQueen(oneSolve, n, n)) { ret.push_back(oneSolve); } */
            ret.push_back(oneSolve);
            return;
        }
        for (int i = 0; i < n; ++i)
        {
            oneSolve[index][i] = 'Q';
            if (!_testQueen(oneSolve, index+1,n))
            {//检查当前行，提前做出决策(相当于剪枝函数)
                oneSolve[index][i] = '.';
                continue;
            }           
            _solves(ret, oneSolve, n, index + 1);
            oneSolve[index][i] = '.';
        }
    }

    bool _testQueen(vector<string>& tmp,int m,int n)
    { // m行，n列(m可能小于n)

        int i = m-1;
        int j = 0;
        for (; j < n; ++j)
        {
            if (tmp[i][j] == 'Q')
            {
                break;
            }
        }

        // tmp[i][j] == 'Q'
        // 检查行
        for (int k = j + 1; k < n; ++k)
        { 
            if (tmp[i][k] == 'Q')
            {
                return false;
            }
        }

        //检查列
        for (int k = 0; k < i; ++k)
        {
            if (tmp[k][j] == 'Q')
            {
                return false;
            }
        }
        for (int k = i + 1; k < m; ++k)
        {
            if (tmp[k][j] == 'Q')
            {
                return false;
            }
        }

        //检查斜线上的
        //左上
        int beginx = i;
        int beginy = j;         
        while (beginx > 0 && beginy > 0)
        {//
            if (tmp[--beginx][--beginy] == 'Q')
            {
                return false;
            }
        }
        //右下
        beginx = i;
        beginy = j;
        while (beginx < m-1 && beginy < n-1)
        {
            if (tmp[++beginx][++beginy] == 'Q')
            {
                return false;
            }
        }
        //左下
        beginx = i;
        beginy = j;
        while (beginx<m - 1 && beginy > 0)
        {
            if (tmp[++beginx][--beginy] == 'Q')
            {
                return false;
            }
        }
        //左上
        beginx = i;
        beginy = j;
        while (beginx > 0 && beginy < n - 1)
        {
            if (tmp[--beginx][++beginy] == 'Q')
            {
                return false;
            }
        }

        return true;
    }
};

这道题的解法思想上和前面的题没什么大的区别，每个位置都去测试一下，把不满足的情况过滤掉，用到算法思想应该是回溯法，还有剪枝函数的思想，代码中关键地方给了注释，在理解了n后规则后应该能看懂这些代码吧！
这次写的代码运行了一次就通过了，还是比较欣慰的，程序的结果如下：