N皇后问题的递归与非递归解法

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/fly_yr/article/details/51135059

题目

 N皇后问题

n皇后问题是将n个皇后放置在n*n的棋盘上,皇后彼此之间不能相互攻击。

给定一个整数n,返回所有不同的n皇后问题的解决方案。

每个解决方案包含一个明确的n皇后放置布局,其中“Q”和“.”分别表示一个女王和一个空位置。

样例

对于4皇后问题存在两种解决的方案:

[

    [".Q..", // Solution 1

     "...Q",

     "Q...",

     "..Q."],

    ["..Q.", // Solution 2

     "Q...",

     "...Q",

     ".Q.."]

]

 N皇后问题 II

根据n皇后问题,现在返回n皇后不同的解决方案的数量而不是具体的放置布局。

样例

比如n=4,存在2种解决方案

分析

 N皇后问题是一个经典的问题,在一个N*N的棋盘上放置N个皇后,每行一个并使其不能互相攻击(同一行、同一列、同一斜线上的皇后都会自动攻击)。

一、 求解N皇后问题是算法中回溯法应用的一个经典案例

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

      在现实中,有很多问题往往需要我们把其所有可能穷举出来,然后从中找出满足某种要求的可能或最优的情况,从而得到整个问题的解。回溯算法就是解决这种问题的“通用算法”,有“万能算法”之称。N皇后问题在N增大时就是这样一个解空间很大的问题,所以比较适合用这种方法求解。这也是N皇后问题的传统解法,很经典。

      下面是算法的高级伪码描述,这里用一个N*N的矩阵来存储棋盘:

      1) 算法开始, 清空棋盘,当前行设为第一行,当前列设为第一列

      2) 在当前行,当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没有两个皇后),若不满足,跳到第4步

      3) 在当前位置上满足条件的情形:

                 在当前位置放一个皇后,若当前行是最后一行,记录一个解;

                 若当前行不是最后一行,当前行设为下一行, 当前列设为当前行的第一个待测位置;

                 若当前行是最后一行,当前列不是最后一列,当前列设为下一列;

                 若当前行是最后一行,当前列是最后一列,回溯,即清空当前行及以下各行的棋盘,然后,当前行设为上一行,当前列设为当前行的下一个待测位置;

                以上返回到第2步

      4) 在当前位置上不满足条件的情形:

                若当前列不是最后一列,当前列设为下一列,返回到第2步;

                若当前列是最后一列了,回溯,即,若当前行已经是第一行了,算法退出,否则,清空当前行及以下各行的棋盘,然后,当前行设为上一行,当前列设为当前行的下一个待测位置,返回到第2步; 

        算法的基本原理是上面这个样子,但不同的是用的数据结构不同,检查某个位置是否满足条件的方法也不同。为了提高效率,有各种优化策略,如多线程,多分配内存表示棋盘等。

        在具体解决该问题时,可以将其拆分为几个小问题。首先就是在棋盘上如何判断两个皇后是否能够相互攻击,在最初接触这个问题时,首先想到的方法就是把棋盘存储为一个二维数组,然后在需要在第i行第j列放置皇后时,根据问题的描述,首先判断是在第i行是否有皇后,由于每行只有一个皇后,这个判断也可以省略,然后判断第j列是否有皇后,这个也很简单,最后需要判断在同一斜线上是否有皇后,按照该方法需要判断两次,正对角线方向和负对角线方向,总体来说也不难。但是写完之后,总感觉很笨,因为在N皇后问题中这个函数的使用次数太多了,而这样做效率较差,个人感觉很不爽。上网查看了别人的实现之后大吃一惊,大牛们都是使用一个一维数组来存储棋盘,在某个位置上是否有皇后可以相互攻击的判断也很简单。

        具体细节如下:

        把棋盘存储为一个N维数组a[N],数组中第i个元素的值代表第i行的皇后位置,这样便可以把问题的空间规模压缩为一维O(N),在判断是否冲突时也很简单,首先每行只有一个皇后,且在数组中只占据一个元素的位置,行冲突就不存在了,其次是列冲突,判断一下是否有a[i]与当前要放置皇后的列j相等即可。至于斜线冲突,通过观察可以发现所有在斜线上冲突的皇后的位置都有规律即它们所在的行列互减的绝对值相等,即| row – i | = | col – a[i] | 。这样某个位置是否可以放置皇后的问题已经解决。

        但是一般来说递归的效率比较差,下面重点讨论一下该问题的非递归实现。

        非递归方法的一个重要问题时何时回溯及如何回溯的问题。程序首先对N行中的每一行进行探测,寻找该行中可以放置皇后的位置,具体方法是对该行的每一列进行探测,看是否可以放置皇后,如果可以,则在该列放置一个皇后,然后继续探测下一行的皇后位置。如果已经探测完所有的列都没有找到可以放置皇后的列,此时就应该回溯,把上一行皇后的位置往后移一列,如果上一行皇后移动后也找不到位置,则继续回溯直至某一行找到皇后的位置或回溯到第一行,如果第一行皇后也无法找到可以放置皇后的位置,则说明已经找到所有的解程序终止。如果该行已经是最后一行,则探测完该行后,如果找到放置皇后的位置,则说明找到一个结果,打印出来。但是此时并不能再此处结束程序,因为我们要找的是所有N皇后问题所有的解,此时应该清除该行的皇后,从当前放置皇后列数的下一列继续探测。

【注:分析内容参考自分析原文

源码I

/*
33 N皇后问题

n皇后问题是将n个皇后放置在n*n的棋盘上,皇后彼此之间不能相互攻击。

给定一个整数n,返回所有不同的n皇后问题的解决方案。
每个解决方案包含一个明确的n皇后放置布局,其中“Q”和“.”分别表示一个女王和一个空位置。
*/

#include <iostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class Solution {
public:
	/**
	* Get all distinct N-Queen solutions
	* @param n: The number of queens
	* @return: All distinct solutions
	* For example, A string '...Q' shows a queen on forth position
	*/
	/*方法一、递归实现*/
	vector<vector<string> > solveNQueens1(int n) {
		// write your code here
		vector<vector<string>> solutions;
		/*用一维数组存储*/
		vector<int> queue(n, -1);
		/*用一维数组存储*/
		recursiveFun(solutions, queue, n, 0);
		return solutions;
	}

	/*递归实现*/
	void recursiveFun(vector<vector<string>> &solutions, vector<int> &queue, int n, int row)
	{
		if (row >= n)
		{
			vector<string> ret = getResult(queue);
			solutions.push_back(ret);
		}//if
		else{
			for (int j = 0; j < n; ++j)
			{
				/*递归在上一个任务成功后*/
				if (isValid(queue, row, j))
				{
					queue[row] = j;
					recursiveFun(solutions, queue, n, row + 1);
				}//if
			}//else
		}//else
	}

	/*方法二、非递归实现*/
	vector<vector<string> > solveNQueens(int n) {
		// write your code here
		vector<vector<string>> solutions;
		/*用一维数组存储*/
		vector<int> queue(n, -1);
		int i = 0, j = 0;
		while(i < n)
		{
			while(j < n)
			{
				if (isValid(queue, i, j))
				{
					/*第i行的皇后的列为j*/
					queue[i] = j;

					/*继续探测下一个皇后的位置*/
					j = 0;
					break;
				}//if
				else{
					++j;
				}//else
			}//while

			/*第i行没有找到可以放置皇后的位置,说明该方案不可行*/
			if (-1 == queue[i])
			{
				/*当前没有可行解的行标为0,说明已经找完所有的解*/
				if (0 == i)
				{
					break;
				}//if
				/*回溯到上一行*/
				else
				{
					--i;
					/*改变上一行皇后的位置*/
					j = queue[i] + 1;
					queue[i] = -1;	
					continue;
				}//else
			}//if

			/*找到一个可行解*/
			if (i == n - 1)
			{
				vector<string> ret = getResult(queue);
				solutions.push_back(ret);

				/*不能在此处结束程序,因为我们要找的是N皇后问题的所有解,此时应该清除该行的皇后,
				从当前放置皇后列数的下一列继续探测。*/
				j = queue[i] + 1;
				queue[i] = -1;
				continue;
			}//if
			++i;
		}//while
		return solutions;
	}


	/*判断在r行c列放置皇后,是否合法*/
	bool isValid(vector<int> queue, int r, int c)
	{
		if (queue.empty())
			return true;
		for (int i = 0; i < r; ++i)
		{		
			if (queue[i] == c || abs(i - r) == abs(queue[i] - c))
				return false;
		}//for
		return true;
	}

	/*将符合要求的结果用字符串数组表示*/
	vector<string> getResult(vector<int> queue)
	{
		if (queue.empty())
		{
			return vector<string>();
		}

		int len = queue.size();
		vector<string> ret(len, string(len,'.'));
		for (int i = 0; i < len; ++i)
		{
			ret[i][queue[i]] = 'Q';
		}//for
		return ret;
	}
};

int main()
{
	Solution s;
	vector<vector<string>> ret = s.solveNQueens1(4);

	for (auto iter1 = ret.begin(); iter1 != ret.end(); ++iter1)
	{
		for (auto iter2 = (*iter1).begin(); iter2 != (*iter1).end(); ++iter2)
		{
			cout << *iter2 << endl;
		}//for
	}//for

	system("pause");
	return 0;
}

GitHub源码

源码II

/*
34 N皇后问题 II

根据n皇后问题,现在返回n皇后不同的解决方案的数量而不是具体的放置布局。
样例
比如n=4,存在2种解决方案
*/

#include <iostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class Solution {
public:
	/**
	* Calculate the total number of distinct N-Queen solutions.
	* @param n: The number of queens.
	* @return: The total number of distinct solutions.
	*/
	int totalNQueens1(int n) {
		// write your code here
		int solutions = 0;
		/*用一维数组存储*/
		vector<int> queue(n, -1);
		/*用一维数组存储*/
		recursiveFun(solutions, queue, n, 0);
		return solutions;
	}

	/*递归实现*/
	void recursiveFun(int &solutions, vector<int> &queue, int n, int row)
	{
		if (row >= n)
		{
			++solutions;
		}//if
		else{
			for (int j = 0; j < n; ++j)
			{
				/*递归在上一个任务成功后*/
				if (isValid(queue, row, j))
				{
					queue[row] = j;
					recursiveFun(solutions, queue, n, row + 1);
				}//if
			}//else
		}//else
	}

	/*方法二、非递归实现*/
	int totalNQueens(int n) {
		// write your code here
		int solutions = 0;
		/*用一维数组存储*/
		vector<int> queue(n, -1);
		int i = 0, j = 0;
		while (i < n)
		{
			while (j < n)
			{
				if (isValid(queue, i, j))
				{
					/*第i行的皇后的列为j*/
					queue[i] = j;

					/*继续探测下一个皇后的位置*/
					j = 0;
					break;
				}//if
				else{
					++j;
				}//else
			}//while

			/*第i行没有找到可以放置皇后的位置,说明该方案不可行*/
			if (-1 == queue[i])
			{
				/*当前没有可行解的行标为0,说明已经找完所有的解*/
				if (0 == i)
				{
					break;
				}//if
				/*回溯到上一行*/
				else
				{
					--i;
					/*改变上一行皇后的位置*/
					j = queue[i] + 1;
					queue[i] = -1;
					continue;
				}//else
			}//if

			/*找到一个可行解*/
			if (i == n - 1)
			{
				++solutions;

				/*不能在此处结束程序,因为我们要找的是N皇后问题的所有解,此时应该清除该行的皇后,
				从当前放置皇后列数的下一列继续探测。*/
				j = queue[i] + 1;
				queue[i] = -1;
				continue;
			}//if
			++i;
		}//while
		return solutions;
	}


	/*判断在r行c列放置皇后,是否合法*/
	bool isValid(vector<int> queue, int r, int c)
	{
		if (queue.empty())
			return true;
		for (int i = 0; i < r; ++i)
		{
			if (queue[i] == c || abs(i - r) == abs(queue[i] - c))
				return false;
		}//for
		return true;
	}
};


int main()
{
	Solution s;
	cout << s.totalNQueens1(4) << endl;
	system("pause");
	return 0;
}
GitHub源码II

展开阅读全文

没有更多推荐了,返回首页