N皇后问题非递归求解(利用对称性优化)

已于 2024-07-18 02:46:30 修改
阅读量3.4k 收藏 13
点赞数 2
分类专栏： 算法 文章标签： 算法
于 2021-12-19 19:07:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/122027981
版权

N皇后问题是一个老掉牙的问题了，随便翻一本算法书籍都能看到对它的介绍，其实N皇后问题可以用非递归方法解决，有效避免N过大时的递归工作栈溢出，且占用的存储空间较小，运行速度也较快，达到运行速度和空间合理利用的两全,代码很简单，并不复杂，有时简单也是一种美，意味着可靠和高效。追求程序的复杂和难以理解的编程者不会认同这一点，但对用简单的设计就可以解决的问题用复杂的数据表示加以描述是没有必要的。

我们可以利用对称性解决N皇后问题：

对于n皇后问题的任意解，把它相对于棋盘中线做对称变换，即让N皇后解中任意一个皇后的列c变为n-c,得到的仍然是n皇后问题的一个解。所以剪枝时对第一行剪枝，让第一行皇后列依次取1, 2,3,–,[n/2],若n为偶数，第一行[n/2]+1,[n/2]+2–n列均不用考虑，直接剪掉,若n为奇数,[n/2]+2,—,n列不用考虑直接剪掉,皇后除放置于第一行1,2–,[n/2]列外还可放置于第一行[n/2]+1列，此时剪掉第二行[n/2]+1,—,n列即可也就是对第二行而言，在第一行已放置在最中间列的皇后限制下第二行1,2–，[n/2]列中所有可放置列关于中线的对称列全部剪掉。

用改进的剪枝策略优化N皇后问题所得代码如下：

#include <iostream>
#include <malloc.h>
#include <math.h>
using namespace std;


int place(int i, int k, int* p, bool* col)
{
	if (col[i - 1])  //该列被占用
		return 0;
	for (int m = 0; m < k; m++)
	{
		if ((abs(m - k) == abs(p[m] - i)))   //k+1行i列不是合法位置
			return (0);
	}
	return (1);   //k+1行i列是合法位置    
}

int find(int n, int* p, int k, bool n_is_odd, bool* col)
{
	int i;
	i = p[k];

	if (k == 1)  //如果当前行为第二行且n为奇数，同时第一行皇后位置为正中间，则第二行最多试探到n/2列终止
	{
		if (n_is_odd && p[0] == n / 2 + 1)
		{
			if (i + 1 < n / 2)
				return i + 1;
			else
			{
				return 0;
			}
		}
	}

	for (i++; i <= n; i++)
	{
		if (place(i, k, p, col) == 1)  //在k+1行找到可放置皇后的列
			return (i);    //返回该列
	}
	return (0);   //在k+1行没有找到可放置皇后的列
}

void output(int n, int* p)
{
	int i, j;

	for (i = 0; i < n; i++)
	{
		for (j = 1; j <= n; j++)
		{
			if (j == p[i])
				printf("1 ");
			else
				printf("0 ");
		}
		printf("\n");
	}
	printf("\n");
}


int main()
{

	int k, n;
	int m;
	int* p;

	printf("you want to solve n queens problem\n");
	printf("n=");
	scanf_s("%d", &n);                   //输入问题规模

	p = (int*)malloc(n * sizeof(int));   //p[k]表示k+1行皇后所在列
	for (k = 0; k < n; k++)
	{
		p[k] = 0;                     //初始化数组p                      
	}

	bool *col = (bool*)malloc(n * sizeof(bool));  //表示列是否被皇后占用的数组
	for (k = 0; k < n; k++)
	{
		col[k] = false;                           
	}

	k = 0;       //初始化为第一行
	m = 0;      //记录解的个数变量初始化
	bool n_is_odd = false;
	if (n % 2 != 0)
	{
		n_is_odd = true;
	}

	int max_col;
	if (n_is_odd)
	{
		max_col = n / 2 + 1;
	}
	else
	{
		max_col = n / 2;
	}

	while (true)
	{
		if (k == 0)   //进入或回溯至第一行
		{
			if (p[k] != 0)
				col[p[k] - 1] = false;
			col[p[k]] = true;
			p[k] = p[k] + 1;   //试探下一列

			if (p[k] > max_col)    //利用max_col剪枝，如果n为奇数, 第一行第n / 2 + 1列试探完毕后终止，否则n / 2列试探完毕后终止
			{
				break;
			}

			k++;    //试探下一行
		}
		else
		{
			int temp;
			if ((temp = find(n, p, k, n_is_odd, col)) == 0)    //k+1行没有找到可放置皇后的位置
			{
				if (p[k] != 0)
				{
					col[p[k] - 1] = false;
					p[k] = 0;   //必要的清理
				}          
				k--;                //回溯
			}
			else
			{
				if (p[k] != 0)
					col[p[k] - 1] = false;
				p[k] = temp;     //在k+1行找到的位置赋予p[k]
				col[temp - 1] = true;
				if (k != (n - 1))     //皇后没有全部放置完毕
				{
					k++;          //试探下一行
				}
				else        //皇后全部放置成功，找到解
				{
					m++;
					printf("The %dnd solution\n", m);
					output(n, p);    //输出解
				}
			}
		}
	}

	printf("There are %d solutions in total\n", m);
	return 0;
}

运行结果

附n皇后问题的递归代码：

该程序段为自己的创作(教科书上现成的代码没必要复制粘贴)，意义不是很大，因为比较繁琐，当n<=8时能输出正确结果,n>8时直接STACKOVERFLOW，所以大家看看就好，并不实用

#include <stdio.h>
#include <math.h>
#include <malloc.h>
#include <stdlib.h>
void print(int n);
void put(int k, int n, int *q, int *p);
void output(int n, int *p);
int law(int k ,int i, int *p);

void main ()
{
    int n;
    printf ("you want to solve the problem of n queens the n=?\n");
    scanf ("%d", &n);
    print(n);
}

void print(int n)
{
    int number, i;
    int *p;
    number=0;
    p=(int *)malloc(n*sizeof(int));
    for (i=0; i<n; i++)
        *(p+i)=0;

    put(1, n, &number, p);

    printf("There are %d solutions in total\n", number);
    free(p);
}
void put(int k, int n, int *q, int *p)
{
    int i;
    if (k==1)
    {
        (*p)++;
        if ((*p)>n)
            return;
        put(k+1, n, q, p);
    }
    else
    {
        i=*(p+k-1);
        i++;
        while (i<=n)
        {
            if (law(k, i, p))
            {
                *(p+k-1)=i;
                if (k==n)
                {
                    (*q)++;
                    printf ("The %dnd solution\n", *q);
                    output(n, p);
                    put(k, n, q, p);
                }
                else
                {
                    put(k+1, n, q, p);
                }
                break;
            }
            i++;
        }
        if (i>n)
        {
            *(p+k-1)=0;
            put(k-1, n, q, p);
        }
    }
}

void output(int n, int *p)
{
    int j, c;
    for (j=1; j<=n; j++)
    {
        for (c=1; c<=n; c++)
        {
            if (c==*(p+j-1))
                printf ("%d", 1);
            else
                printf ("%d", 0);
        }
        printf ("\n");
    }
    printf ("\n");
}

int law(int k ,int i, int *p)
{
    int m;
    for (m=1; m<k; m++)
    {
        if ((*(p+m-1)==i)||(abs(m-k)==abs(*(p+m-1)-i)))
            return(0);
    }
    return(1);
}

下面是一个优化过的版本,用left_slope_restrict和right_slope_restrict数组记录被皇后所在的斜线占据的各列,col数组指明那些列已被皇后占用,这样可以使皇后放置位置的判断的时间复杂度达到O(1)

空间复杂度仍为O(n)只有每次抵达新的一行或从一行回溯至上一行时会以O(n)的时间复杂度更新

left_slope_restrict和right_slope_restrict,而未优化的版本每次在一行上多次搜索时每次都要以O(n)的时间复杂度判断位置能否放置皇后，所以每一行的时间复杂度从平方级减到线性，应该是能加速问题求解的

C++代码:

#include <iostream>
#include <malloc.h>
#include <math.h>
using namespace std;


int place(int i, int k, int* p, bool* col, bool* left_slope_restrict, bool* right_slope_restrict)
{
	if (col[i - 1] || left_slope_restrict[i - 1] || right_slope_restrict[i- 1])  //该列被占用,//k+1行i列不是合法位置
		return 0;
	return (1);   //k+1行i列是合法位置    
}

int find(int n, int* p, int k, bool n_is_odd, bool* col, bool* left_slope_restrict, bool* right_slope_restrict)
{
	int i;
	i = p[k];

	if (k == 1)  //如果当前行为第二行且n为奇数，同时第一行皇后位置为正中间，则第二行最多试探到n/2列终止
	{
		if (n_is_odd && p[0] == n / 2 + 1)
		{
			if (i + 1 < n / 2)
				return i + 1;
			else
			{
				return 0;
			}
		}
	}

	for (i++; i <= n; i++)
	{
		if (place(i, k, p, col, left_slope_restrict, right_slope_restrict) == 1)  //在k+1行找到可放置皇后的列
			return (i);    //返回该列
	}
	return (0);   //在k+1行没有找到可放置皇后的列
}

void output(int n, int* p)
{
	int i, j;

	for (i = 0; i < n; i++)
	{
		for (j = 1; j <= n; j++)
		{
			if (j == p[i])
				printf("1 ");
			else
				printf("0 ");
		}
		printf("\n");
	}
	printf("\n");
}

void left_moved(bool* cur, int n)
{
	for (int i = 1; i < n; ++i)
	{
		cur[i - 1] = cur[i];
	}
}

void right_moved(bool* cur, int n)
{
	for (int i = n - 1; i > 0; --i)
	{
		cur[i] = cur[i - 1];
	}
}

int main()
{

	int k, n;
	int m;
	int* p;

	printf("you want to solve n queens problem\n");
	printf("n=");
	scanf_s("%d", &n);                   //输入问题规模

	p = (int*)malloc(n * sizeof(int));   //p[k]表示k+1行皇后所在列
	for (k = 0; k < n; k++)
	{
		p[k] = 0;                     //初始化数组p                      
	}

	bool *col = (bool*)malloc(n * sizeof(bool));  //表示列是否被皇后占用的数组
	for (k = 0; k < n; k++)
	{
		col[k] = false;                           
	}

	bool* left_most_be_removed = (bool*)malloc(n * sizeof(bool));  //保存每次左移时被移出的值
	bool* right_most_be_removed = (bool*)malloc(n * sizeof(bool));  保存每次右移时被移出的值

	//从左至右依次从左至右记录对应各列是否在左斜线上被皇后占据
	bool* left_slope_restrict = (bool*)malloc(n * sizeof(bool)); 
	for (k = 0; k < n; k++)
	{
		left_slope_restrict[k] = false;
	}
	//从左至右依次从左至右对应各列是否咋右斜线上被皇后占据
	bool* right_slope_restrict = (bool*)malloc(n * sizeof(bool));
	for (k = 0; k < n; k++)
	{
		right_slope_restrict[k] = false;
	}

	k = 0;       //初始化为第一行
	m = 0;      //记录解的个数变量初始化
	bool n_is_odd = false;
	if (n % 2 != 0)
	{
		n_is_odd = true;
	}

	int max_col;
	if (n_is_odd)
	{
		max_col = n / 2 + 1;
	}
	else
	{
		max_col = n / 2;
	}

	while (true)
	{
		if (k == 0)   //进入或回溯至第一行
		{
			if (p[k] != 0)
				col[p[k] - 1] = false;
			col[p[k]] = true;
			p[k] = p[k] + 1;   //试探下一列

			if (p[k] > max_col)    //利用max_col剪枝，如果n为奇数, 第一行第n / 2 + 1列试探完毕后终止，否则n / 2列试探完毕后终止
			{
				break;
			}

			k++;    //试探下一行
		}
		else
		{
			if (p[k] == 0)    //抵达新的一行,因此计算出该行对应的left_slope_restrict和right_slope_restrict
			{
				left_most_be_removed[k] = left_slope_restrict[0];
				left_slope_restrict[p[k - 1] - 1] = true;
				left_moved(left_slope_restrict, n);
				left_slope_restrict[n - 1] = false;

				right_most_be_removed[k] = right_slope_restrict[n - 1];
				right_slope_restrict[p[k - 1] - 1] = true;
				right_moved(right_slope_restrict, n);
				right_slope_restrict[0] = false;
			}
			int temp;
			if ((temp = find(n, p, k, n_is_odd, col, left_slope_restrict, right_slope_restrict)) == 0)    //k+1行没有找到可放置皇后的位置
			{
				if (p[k] != 0)
				{
					col[p[k] - 1] = false;
					p[k] = 0;   //必要的清理

				} 
				right_moved(left_slope_restrict, n);
				left_slope_restrict[0] = left_most_be_removed[k];
				left_moved(right_slope_restrict, n);
				right_slope_restrict[n - 1] = right_most_be_removed[k];
				--k;  //回溯,还原出当前行的上一行各列对应的left_slope_restrict和right_slope_restrict
				left_slope_restrict[p[k] - 1] = false;
				right_slope_restrict[p[k] - 1] = false;
			}
			else
			{
				if (p[k] != 0)
					col[p[k] - 1] = false;
				p[k] = temp;     //在k+1行找到的位置赋予p[k]
				col[temp - 1] = true;


				if (k != (n - 1))     //皇后没有全部放置完毕
				{
					k++;          //试探下一行
				}
				else        //皇后全部放置成功，找到解
				{
					m++;
					printf("The %dnd solution\n", m);
					output(n, p);    //输出解
				}
			}
		}
	}

	printf("There are %d solutions in total\n", m);
	return 0;
}

naturerun
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[回溯法]八皇后问题的递归与非递归算法
欲买桂花同载酒，终不似，少年游。
12-20 3615
八皇后的问题非常有名，初次理解可能稍有难度，不过多看书，看博客和代码，几遍下来，也基本清晰。首先不用想初始的情况，先假设前面已经排列好了几个皇后，即将排列下一个皇后。依次遍历八个位置，然后与之前的进行判断这个位置是否可行，如可行则进行下一个皇后，否则则移动位置继续判断。很简单。但是有两个个问题：1、不全，某个位置有八种方法排列，你只用了一种，当然你可以每个位置遍历，但太耗时，回溯法可以解决很大的一部
非递归法实现n皇后问题
11-17
本资源是数据结构中利用非递归法实现n皇后问题的一个C++代码，仅供参考，欢迎指正
算法设计与分析-回溯法思想的应用(头歌实验)
qq_62524881的博客
04-19 4884
算法设计与分析—头歌实验
回溯法思想的应用（头歌）
最新发布
席万里的博客
05-08 163
头哥
n皇后问题的解法
Ethan的博客
10-08 1160
一、 求解N皇后问题是算法中回溯法应用的一个经典案例 回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 下面是算法的高级伪码描述，这里用一个N*N的矩阵来存储棋盘：       1) 算法开始, 清空棋盘，当前行设为第一行，当前列设为第一列       2) 在当前行，当前列的位置上判断
回溯法拓展2 educoder
qq_46675545的博客
06-18 1769
第1关：非递归实现皇后问题 任务描述 本关任务：在n×n格的棋盘上放置彼此不受攻击的 n 个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。用非递归算法解决该问题。 ...
N皇后问题的不递归解法和递归解法(C语言)
viperd的博客
09-27 627
n 皇后问题，研究的是如何将 n 个皇后放置在 n×n 的棋盘上，如果一个皇后出现在另一个皇后的同一行，同一列或者斜对角，那么则失败。可以通过列举出在棋盘上所有的情况，然后判断每个组合是不是符合的条件。一、N皇后问题的概念。
n-皇后问题dfs（c++）
falldeep的算法世界
07-13 424
题目 n−皇后问题是指将n个皇后放在n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数n，请你输出所有的满足条件的棋子摆法。 输入格式 共一行，包含整数n。 输出格式 每个解决方案占n行，每行输出一个长度为n的字符串，用来表示完整的棋盘状态。 其中.表示某一个位置的方格状态为空，Q表示某一个位置的方格上摆着皇后。 每个方案输出完成后，输出一个空行。 注意：行末不能有多余空格。 输出方案的顺序任意...
C语言实现N皇后问题非递归求解
12-25
N皇后问题是一个经典的计算机科学问题，...总的来说，C语言实现的非递归N皇后问题解法避免了递归可能导致的栈溢出问题，同时减少了空间需求。这种方法虽然简单，但能够有效地解决问题，体现了算法设计的简洁性和效率。
迷宫问题求解、迷宫问题非递归求解
03-08
迷宫问题是一个经典的路径...总之，非递归解决迷宫问题的核心在于使用广度优先搜索策略，通过顺序栈保存状态，避免了递归带来的空间复杂性问题。在实际编程中，需要编写相应的代码来处理迷宫的输入、路径搜索和输出。
N皇后问题非递归算法
12-25
N后问题，用非递归的方式去求解。
用栈求解n皇后问题.docx
03-16
总结起来，用栈求解N皇后问题的关键在于利用栈的特性进行回溯搜索，通过检查每一步的可行性来逐步接近正确的解决方案。这种方法简洁高效，能够找到所有可能的解。通过这个经典问题，我们可以深入理解栈的数据结构...
用栈求解n皇后问题 n皇后问题（C语言实现）
07-05
用栈求解n皇后问题（C语言实现） 本文将详细介绍如何使用栈来解决n皇后问题，并提供了一个使用C语言实现的实例代码。 栈的概念 在计算机科学中，栈是一种常用的数据结构，栈是一种后进先出的数据结构，元素的添加...
cpp回溯法（非递归）实现求解n皇后问题
qq_47780707的博客
11-09 1331
cpp回溯法（非递归）实现求解n皇后问题 输入：n 输出：n皇后的所有方案和方案总数 一、主要思路： 1.1所用数据结构： 用x数组存放解序列，其中x[i]表示第i行的n皇后放置的列数，x[0]不使用，初始时x[i]=i。用m[i]数组保存x[i]的下一个交换位置（在回溯时使用）。 //x向量记录解空间 vector<int> x; //m[i]记录每次x[i]的遍历起点，结点i向i+1前进时记录当前x[i]的下一个遍历位置（如当x[1]与x[5]交换时成立，进入x[3]时记录m[1]=5+1）
八皇后非递归解法
weixin_42325110的博客
08-04 1711
问题描述： 在8*8的国际象棋棋盘上，现要放上8个皇后，要求所有皇后都不得在同一行、一列、一斜线上，输出所有可能的放法。 方法： 逐行试探，行就不用考虑了，只需要考虑每次放置时是不是有同列、同斜线的。因为如果按照行去排，给这行放一个就可以跳到下一行了。 图： 分析： 1. 从0行开始，有8个格子，1个1个试探。（0,0）可以吗？ 可以 break; 2. 到第一行：（1,0）可以...
用非递归的方法实现N皇后问题
Ineedmoney2333的博客
05-23 1847
使用循环的方式来解决八皇后问题， 其基本思路和递归方式差不多， 只是在BackTrack函数上面有一些不同，将原来的递归改为循环的方式。 ​ //用循环实现皇后问题。非递归。 class Nqueen{ int n; int []x; int sum; public Nqueen(int nx){ n = nx; x = new int[n+1]; sum = 0; } public boo.
N皇后非递归实现
ljwjojoyy的博客
11-12 712
N皇后非递归实现 马上上课了，以后有时间再细说。。。。。。 回溯：（偷个懒，从老师ppt上拷过来） •状态树（解空间树） –回溯法的求解过程实质上是一个先序遍历一颗状态树的过程，只是这棵状态树不是预先建立的，而是隐含在遍历过程中。 （可以通过画一个四皇后的解空间树来很嗨的理解，理解回溯的过程，图片有时间就更） •约束函数 •节点与解 –完全解 –部分解，继续搜索 –死节点，回溯...
N皇后问题的递归和非递归（栈的方式）解决
m0_75155741的博客
04-02 395
陈述了N皇后的大概的两种解决方法，多多少少有点问题
N皇后问题的递归回溯和非递归非回溯方法（源码）c语言
weixin_52041224的博客
11-17 1505
递归回溯和非递归回溯思路解决N皇后问题
用非递归回溯法求解n皇后问题
06-02
n皇后问题是指在n×n的棋盘上放置n个皇后，使得皇后之间互不攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。下面是用非递归回溯法求解n皇后问题的伪代码： 1. 初始化棋盘：将棋盘上的所有位置都置为0（表示该位置没有皇后）。 2. 从第一行开始，依次放置皇后： for i = 0 to n-1 do 在第i行中找到一个可以放置皇后的位置j： 如果第i行的第j列可以放置皇后并且第i列、第i个主对角线和第i个副对角线上都没有皇后，则将皇后放置在第i行的第j列，并将该位置标记为已放置皇后。 如果找不到可以放置皇后的位置，则回溯到上一行，取消上一行放置的皇后，并在上一行中继续寻找可以放置皇后的位置。 3. 重复步骤2，直到找到一组解或者所有的解都已经找到。 需要注意的是，在非递归回溯法中，需要使用一个栈来保存每一行已经放置的皇后的位置，以便在回溯时能够快速地找到上一行已经放置的皇后，并进行取消操作。此外，还需要使用一个计数器来记录已经找到的解的数量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值