C解决八皇后问题

最新推荐文章于 2024-11-10 10:00:43 发布
最新推荐文章于 2024-11-10 10:00:43 发布
阅读量150 收藏
点赞数
分类专栏： c语言 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mpnet/article/details/133995535
版权

问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
在这里插入图片描述
思路1

  1. 棋盘是8乘8块格子，那么用8乘8的数组来表示棋盘是合适的
  2. 一个位置能否放置格子，得看他的衡竖方向的直线，以及斜线是否有皇后，如果有，则不能放置。如图：在这里插入图片描述
    这里k表示斜率，以（0，0）为坐标原点的话，两条斜线的斜率分别为1和-1。那么根据点斜式：y - y0 = k(x - x0)，变式为:y = kx +b。
    所以这两条斜线的方程为:y = x + y0 -x0,以及y = x0 + y0 - x;另外两条更是十分轻松，分别是,y = y0,x = x0。所以，根据这些原理编写一个是否能放置皇后位置的函数,该函数接受一个坐标(x,y)以及表示棋盘的二维数组,若可以放置就返回1，否则返回0:
int check_queen(int x,int y,int queens[][8])
{

//标志量，都为1则表示可放置皇后，默认为可放置皇后
	int flag_x = 1;
	int flag_y = 1;
	int flag_NE = 1;
	int flag_NW = 1;
	
	//x方向上的检查,按行放置的话，这段代码可免。建议先把下面这段注释取消掉
	/**
	for( int i = 0;i < MAX_SIZE; i++){
		
		if( queens[x][i] == 'Q'){
			flag_x = 0;
			break;
		}
	} 
	*/
	
	//y方向上的检查 这两个代码块其实是可以合并成一个代码块的,但是也会带来潜在的隐患 
	for( int i = 0; i< MAX_SIZE; i++){
		
		if(queens[i][y]){
			flag_y = 0;
			break;
		}
	}
	// 由斜率 y - y1 = k(x - x1 ) 变换而来的 y = kx + b 
	
	int b1 = y -x;
	int b2 = x + y;
	
	//斜率为1方向上的检查
	for( int i = 0; i < MAX_SIZE; i++){
		
		//之所以用cotinue是因为有些斜线所穿过的格子并不全在8乘8的棋盘里 
		if( i + y - x > 7 || i + y - x < 0)continue;
		
		if( queens[i][ i + y - x]){
			flag_NE = 0;
			break;
		}
	} 
	
	//斜率为-1方向上的检查,这两个虽然也可以进行合并，但是由于判断条件不同,所以，不推荐进行合并 
	for( int i = 0; i < MAX_SIZE; i++){
		
		if( x + y - i > 7 || x + y -i < 0)continue;
		if( queens[i][ x + y - i]){
			flag_NW = 0;
			break;
		}
	}
	
	if( flag_x && flag_y && flag_NE && flag_NW){
		return 1;
	}
	else{
		return 0;
	}
}

3.接下来便是问题的关键。
我们怎么放置皇后呢？
默认的思路是。从第0行开始，检查当前位置是否能放置一个皇后，若不能则寻找该行的下一个能放置皇后的位置，若找到了一行的列尾部，那么程序就该返回。若能放置皇后，就放置皇后，并进入下一行，然后进入第一步，直到找到最后一行的皇后被放置，然后返回。根据这个思路，我们编写函数如下（该函数接受一个行数，和一个表棋盘的二维数组):

void travelsing_chessBoard(int cols,int queens[][8])
{
	

	for( int i = 0; i < MAX_SIZE; i++)
	{
		if( check_queen(cols,i,queens) ){
			
		

			queens[cols][i] = 'Q';
			
			//成功放置一个皇后，则进入下一行的皇后检查，如果已经是最后一行,那么就返回 
			if( cols == MAX_SIZE - 1)
			{
				//打印棋盘 
				print_chessBoard(queens);
				
				return;
			}
			travelsing_chessBoard( cols + 1,queens);
		}
				
	}
	
	
	//如果出了行的遍历,就代表到达了行末还没有找到可以放皇后的位置应该返回 
	return;	
	
	
}

在这里先放出程序的主体:

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX_SIZE 8

int Chess_manual = 0; 

int check_queen(int x,int y,int queens[][8]);
/*
*参数列表的cols和rows是x坐标和y坐标,表面目前检查的位置 
*/ 

//棋盘打印函数
void print_chessBoard(int queens[][8]);

void travelsing_chessBoard(int cols,int queens[][8])

int main()
{
	int queens[MAX_SIZE][MAX_SIZE] = {0};
	travelsing_chessBoard(0,queens);
	printf("\n共有%d张棋谱",Chess_manual);
 }

当把检查函数(检查函数x的方向上注释应该去掉)和遍历函数填进去，执行后，程序输出0个棋盘。
这是为什么呢？很明显，我们人工遍历一次就可以知道了。
这就是刚才程序的执行结果
在这里插入图片描述第五行的皇后被放置之后，第六行便没有合适的位置来放置皇后呢。而此时皇后的放置行数没有达到最后一行，所以不会打印棋盘。

		//成功放置一个皇后，则进入下一行的皇后检查，如果已经是最后一行，那么打印棋盘,然后返回 
			if( cols == MAX_SIZE - 1)
			{
				
				print_chessBoard(queens);
				
				return;
			}

所以程序最后到第6行的末尾，然后返回，即：

//如果出了行的遍历,就代表到达了行末还没有找到可以放皇后的位置应该返回 
	return;

就这样，程序返回到了第五行所放置皇后的下一个位置，因为该位置有皇后了，所以后面的位置都不能放皇后，所以这样一直返回到了第0行，程序结束。
这就暴露了刚才所编写函数的缺点了。

  1. 死路问题：当k(k > 1)行不能放置皇后，程序返回到(k - 1)行后，该行皇后位置并没有做出更改。导致程序不能走其他路，就陷入了死路。所以，我们应该移动k-1行的皇后的位置,然后重新走一遍。也就是说：当k行无法放皇后的时候，我们应该移动k-1行皇后的位置，然后在走一遍。

所以对函数改进一下(注释掉x方向上的检查)，变为:

	int rows_note = 1; //用于记录本行皇后的位置 
	int num = 0;	  // 用于记录本行皇后的数量 

	for( int i = 0; i < MAX_SIZE; i++)
	{
		if( check_queen(cols,i,queens) ){
			
			//当一行放置了大于一个的皇后的时候,移除掉前面放置的皇后。因为是按行的顺序放置的，所以说，行的检查是要避免的 
			if(num > 0){
				
				queens[cols][rows_note] = 0;
				num--;
				
			}

			queens[cols][i] = 'Q';
			rows_note = i;
			num++;
			
			//成功放置一个皇后，则进入下一行的皇后检查，如果已经是最后一行,那么就返回 
			if( cols == MAX_SIZE - 1)
			{
				//打印棋盘 
				print_chessBoard(queens);
				
				return;
			}
			travelsing_chessBoard( cols + 1,queens);
		}
				
	}
	//如果出了行的遍历,就代表到达了行末还没有找到可以放皇后的位置应该返回 
	return;

执行后，函数依然是0张棋谱,这是为什么？我们在跟着程序返回一遍。
因为即使我们想更改第五行的皇后的位置，但是并没有第五行第二个位置可以放皇后了，所以程序返回到第四行放皇后的地方。同样是没有合适的位置，就这样一直放回到第0行。这一切的根源是我们想更改第五行的皇后的位置时，没有合适的位置了，但是我们没有清空他，导致第四行皇后取舍的时候会受到它的英雄。这也是一个死路问题。没有位置再放第二个，就代表该行的遍历出了for循环,，所以我们在该函数的最后一个return前加上这句:

queens[cols][rows_note] = 0;

再次运行或发现，程序的输出结果只有一次(字符Q的值是81）。即:在这里插入图片描述多次运行都是这个结果，这是为什么呢？
很明显，当每一行都正确放置了皇后后，函数就直接返回了。因为什么？其实皇后放到最后一行，也是死路，虽然是我们要的结果，但我们并没有清除，也就是说函数返回时，他依然会发生我们前面说的低层皇后影响上一层皇后的取舍问题。所以，当最后一行的皇后成功放置时，打印棋盘后，将皇后去掉。即：

queens[cols][rows_note] = 0;

在调用打印棋盘函数之后加上这句，程序便可正确输出了。
可见，主要是死路问题阻挠了程序的执行。
但死路的表现形式又是多种多样化的，有行内的影响，有上下行的影响。
另外每一条代码并不都是全时段有效代码，比如，当成功找到最后一行的一个皇后，程序还试图在该行寻找第二个皇后等。是无效也是无意义的。但是，如果删掉这一步骤，则有多个合适位置放皇后的行便会收到影响。也就是说，是否进行优化，还是有讨论性的。

这就是本文的完整代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX_SIZE 8

int Chess_manual = 0; 

int check_queen(int x,int y,int queens[][8])
{
	int flag_x = 1;
	int flag_y = 1;
	int flag_NE = 1;
	int flag_NW = 1;
	
	//x方向上的检查,按行放置的话，这段代码可免
	/**
	for( int i = 0;i < MAX_SIZE; i++){
		
		if( queens[x][i] == 'Q'){
			flag_x = 0;
			break;
		}
	} 
	*/
	
	//y方向上的检查 这两个代码块其实是可以合并成一个代码块的,但是也会带来潜在的隐患 
	for( int i = 0; i< MAX_SIZE; i++){
		
		if(queens[i][y]){
			flag_y = 0;
			break;
		}
	}
	// 由斜率 y - y1 = k(x - x1 ) 变换而来的 y = kx + b 
	
	int b1 = y -x;
	int b2 = x + y;
	
	//斜率为1方向上的检查
	for( int i = 0; i < MAX_SIZE; i++){
		
		//之所以用cotinue是因为有些斜线所穿过的格子并不在8乘8的棋盘里 
		if( i + y - x > 7 || i + y - x < 0)continue;
		
		if( queens[i][ i + y - x]){
			flag_NE = 0;
			break;
		}
	} 
	
	//斜率为-1方向上的检查,这两个虽然也可以进行合并，但是由于判断条件不同,所以，不推荐进行合并 
	for( int i = 0; i < MAX_SIZE; i++){
		
		if( x + y - i > 7 || x + y -i < 0)continue;
		if( queens[i][ x + y - i]){
			flag_NW = 0;
			break;
		}
	}
	
	if( flag_x && flag_y && flag_NE && flag_NW){
		return 1;
	}
	else{
		return 0;
	}
}

/*
*参数列表的cols和rows是x坐标和y坐标,表面目前处理的位置 
*/ 

void print_chessBoard(int queens[][8])
{
	printf("\n**************************************************************\n");
	for(int i = 0; i < MAX_SIZE; i++){
		
		for(int j = 0; j < MAX_SIZE; j++){
			
			printf(" %d ",queens[i][j]);
			
		}
		
		printf("\n"); 
	}
	
	Chess_manual++;
}



void travelsing_chessBoard(int cols,int queens[][8])
{
	
	int rows_note = 1;
	int num = 0;
	
	for( int i = 0; i < MAX_SIZE; i++)
	{
		if( check_queen(cols,i,queens) ){
			
			
			//当一行放置了大于一个的皇后的时候,移除掉前面放置的皇后。因为是按行的顺序放置的，所以说，行的检查是可以避免的 
			if(num > 0){
				
				queens[cols][rows_note] = 0;
				num--;
				
			}

			queens[cols][i] = 'Q';
			rows_note = i;
			num++;
			
		
			//成功放置一个皇后，则进入下一行的皇后检查，如果已经是最后一行就清空本层皇后,然后返回 
			if( cols == MAX_SIZE - 1)
			{
				print_chessBoard(queens);
				
				queens[cols][rows_note] = 0;
				return;
			}
			travelsing_chessBoard( cols + 1,queens);
		}
		
	}
	//如果已经达到了行的末尾，那么本行中的皇后清0，为返回上一层的枝做空间清理
	queens[cols][rows_note] = 0; 
	return;	
	
} 

int main()
{
	int queens[MAX_SIZE][MAX_SIZE] = {0};
	travelsing_chessBoard(0,queens);
	printf("\n共有%d张棋谱",Chess_manual);
 }

现在再来看这三句注释,其实就是被我们忽视的死路处理:

  1. 当一行放置了大于一个的皇后的时候,移除掉前面放置的皇后。因为是按行的顺序放置的，所以说，行的检查是可以避免的
  2. 成功放置一个皇后，则进入下一行的皇后检查，如果已经是最后一行就清空本层皇后,然后返回
  3. 如果已经达到了行的末尾，那么本行中的皇后清0，为返回上一层的枝做空间清理

程序结果如图:
在这里插入图片描述

利用C语言解决八皇后问题以及解析
01-01
八皇后问题是一个古老而著名的问题。该问题是19世纪著名的数学家高斯1850年提出：在一个8*8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后之间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列...
【职业规划】八皇后问题
heroybc的博客
11-27 1386
- 八皇后问题 是回溯算法的典型例题。 该问题是十九世纪著名的数学家高斯1850年提出： 在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击。 即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 正确的结果应该是： 92种。 第1次考虑把皇后放在第1行的某个位置。 第2次放的时候就不用去放在第一行了，因为这样放皇后间是可以互相攻击的。 第2次就考虑把皇后放在第2行的某...
c语言解决八皇后问题
05-24
C语言解决八皇后问题 八皇后问题是计算机科学中经典的问题之一，目的是在8x8的棋盘上摆放八个皇后，使得每个皇后都不在同一行、同一列或同一对角线上。以下是使用C语言解决八皇后问题的代码和解释。 问题描述 八...
C语言基于回溯算法解决八皇后问题的方法
08-27
主要介绍了C语言基于回溯算法解决八皇后问题的方法,简单描述了八皇后问题,并结合实例形式分析了C语言使用回溯算法解决八皇后问题的相关操作技巧,需要的朋友可以参考下
C语言解决八皇后问题
03-12
八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。 该问题是十九世纪著名的数学家高斯1850年提出： 在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击， 即任意两个皇后都不能处于同一行、同一列或同一...
如何让GCC生成编译过程的中间文件(.i/.s/.o)?gcc 1.c和g++ 1.c有什么区别?gcc 1.c和g++ 1.c预处理有什么区别?
最新发布
编程语言技巧经验分享
11-10 660
可以用--save-temps选项指示GCC生成编译过程中的中间文件。
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 366
Leetcode 160. 相交链表
二分查找习题篇(上)
zoelinkailuo的博客
11-07 941
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 865
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 483
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 309
LeetCode 416. 分割等和子集
69. x 的平方根
学习历程记录和分享
11-06 182
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
2024年华为OD机试真题-矩阵扩散-Java-OD统一考试（E卷）
面试高手的博客
11-06 179
时间复杂度为O(m * n)，因为每个点最多会被访问一次，每次访问时会扩展到它的邻居点，所有的扩展过程一共涉及m×n个点。- 当队列为空时，表示矩阵中所有点都已经被扩散，这时输出最大的扩散时间，即为整个矩阵所有点变为1所需的时间。- 使用一个二维数组dist来记录每个点的扩散时间，初始时所有点的时间设为-1，表示未被访问。- 如果邻居点未被访问（时间为-1），则将其扩散为1，并将该点的时间设为当前点的时间+1。- 我们从两个扩散点同时开始扩散，将其周围为0的点转化为1，并逐步向外扩展。
算法通关（4）-- 前缀树
2301_79985750的博客
11-07 996
前缀树（Trie树），也称为字典树，是一种用于的数据结构。它是一种树形结构，能够利用字符串的公共前缀来减少存储空间和查询时间。现在有“acb”,"cba","acc"，"ac"四个字符串，利用这四个字符串构出一颗前缀树。根节点不包含任何字符，是所有字符串的公共前缀；每个节点包含pass信息，代表加节点的时候路过了几次，还有一个end信息表示多少个字符串是以当前字符串结尾的。举个例子：插入完成后得到的树形结构：那么现在问：字符串acb出现了几次。
人脸识别技术：从算法到深度学习的全面解析
梵心白莲的博客
11-07 1014
人脸识别技术作为一种重要的生物识别技术，在当今社会中具有举足轻重的地位。它广泛应用于各个领域，如金融领域的实名认证、安保领域的门禁系统、通行领域的火车站和地铁站检票、泛娱乐领域的美颜相机和短视频特效处理、公安和司法领域的逃犯追捕和服刑人员管理、自助服务设备以及考勤和会务等。
贪心算法day3（最长递增序列问题）
2301_80785428的博客
11-08 330
思路：我们只需要设置两个数进行比较就好。设a为nums[0]，b 为一个无穷大的数，只要有比a小的数字就赋值a，比a大的数字就赋值b，如果有比b大的数字说明可以组成一个三元子序列直接返回true。
桶排序js
weixin_46253800的博客
11-07 306
是一种基于分布的排序算法。它将数据分布到一定数量的桶中，然后对每个桶中的数据进行排序，最后将所有桶中的数据合并成一个有序的结果。桶排序通常用于已知数据分布范围比较均匀的情况。
【EMNLP2024】基于多轮课程学习的大语言模型蒸馏算法 TAPIR
科技很有意思
11-08 790
阿里云人工智能平台 PAI与复旦大学王鹏教授团队合作，在自然语言处理顶会EMNLP 2024上发表论文《Distilling Instruction-following Abilities of Large Language Models with Task-aware Curriculum Planning》。
01背包模板+空间压缩优化
aoe_z的博客
11-06 946
01背包模板+空间压缩优化01背包模板。
C语言编程解决八皇后问题
这个C语言代码利用了递归算法和回溯法来解决八皇后问题。递归函数`qu`在每一步都尝试所有可能的皇后位置，通过不断尝试和回溯来寻找所有可能的解决方案。由于八皇后问题有多个解，因此程序会输出所有可能的棋盘布局...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值