N皇后问题的递归算法和非递归算法

【问题描述】在一个N*N的棋盘上，摆放N个皇后。满足：任何两个皇后不得在同一行、或者同一列、或者同一斜线。找出所有满足条件的布局。

思路：假设前i-1行的皇后已经安放成功，现在要在第i行的适当列安放皇后，使得它与前i-1行安放的皇后在行方向、列方向和斜线方向不冲突。为此，试探第i行的所有n个位置（列），如果某一列能够安放皇后，就可以递归到第i+1行继续寻找下一个皇后可安放的位置，一直到第n行。如果第i行的所有位置（列）都不能安放皇后，则回溯到i-1行，寻找i-1行下一个可以安放皇后的位置，如果在i-1找到下一个位置，递归到第i行，否则回溯到i-2行。

1.递归算法实现代码如下：

//数组G用来保存皇后安放的位置,res用来保存所有合法布局
void Queen(int G[], const int& n, int i, vector<vector<int>>& res)
{
	if (i == n)
	{
		res.push_back(vector<int>(G, G + n));
		return;
	}
	for (int j = 0; j < n; ++j)
	{
		bool conflict = false;
		for (int k = 0; k < i; ++k)
		{
			if (j == G[k] || i - k == j - G[k] || i - k == G[k] - j)
			{
				conflict = true;
				break;
			}
		}
		if (!conflict)
		{
			G[i] = j;
			Queen(G, n, i + 1, res);
		}
	}
}

2.非递归实现：

将递归算法转化成非递归算法的关键是使用栈来记忆递归回退的路径。

vector<vector<int>> Queen2(int n)
{
	if (n < 1) return vector<vector<int>>();
	vector<vector<int>> res;
	int *stack = new int[n];  //保存皇后位置的栈
	int top = -1;  //栈顶
	stack[0] = 0; top = 0;  //第一个皇后位置压栈
	int row = top + 1, col = 0;
	while (1)  
	{
		if (top == n-1)
		{
			//栈满，找到一组布局
			res.push_back(vector<int>(stack, stack + n));
			col = stack[top] + 1;
			--top;  //出栈
		}
		//向前试探
		row = top + 1;  
		while (col < n)
		{
			bool conflict = false;
			for (int k = 0; k < row; ++k)
			{
				if (col == stack[k] || row - k == col - stack[k] || row - k == stack[k] - col)
				{
					conflict = true; break;
				}
			}
			//没有冲突，可行
			if (!conflict)
			{
				stack[++top] = col;
				break;
			}
			++col;
		}
		//没有解，试探失败，回溯
		if (row != top)
		{
			if (top == -1) break;  //空栈，结束
			col = stack[top] + 1;
			--top;   //出栈
		}
		//继续向前试探
		else
		{
			col = 0;
		}
	}
	delete[] stack;
	return res;
}