C语言【微项目10】—棋盘覆盖问题[递归到基本四格单位时填充]（采用分治法实现）【2021-11-27】

最新推荐文章于 2024-02-06 17:25:29 发布
最新推荐文章于 2024-02-06 17:25:29 发布
阅读量1k 收藏 8
点赞数 15
分类专栏： C语言-微项目 文章标签： c语言 分治法 棋盘覆盖问题 图形式填充 排他式填充
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54698498/article/details/121582250
版权

C语言【微项目10】—棋盘覆盖问题[递归到基本四格单位时填充]（采用分治法实现）【2021-11-27】


【TDTX】

【MyCoverBoardA.c】把棋盘的填充视为：【排除缺陷式】位置填充；
【MyCoverBoardB.c】把棋盘的填充视为：【图形卡位式】位置填充；
【总结】两者最终的结果完全相同，但视觉效果不同。

一、MyCoverBoardA.c

#include <stdio.h>
#include <stdlib.h>
int qa,qb;
int mpow(int n,int k)
{
	int i;
	int t = n;
	for(i = 1; i < k;i++)
	{
		t = t * n;
	}
	return t;
}
void generateBoard(int tr,int tc,int dr,int dc,int size,int** b,int* t1)
{
	int hs = size / 2;
	if(size == 2)
	{
		if( dr == tr && dc == tc )
		{
			//残缺位置在4格左上角 
			b[tr][tc+1] = *t1;
			b[tr+1][tc] = *t1;
			b[tr+1][tc+1] = *t1;
			(*t1)++; 
		}
		if( dr== tr && dc == tc + 1)
		{
			//残缺位置在4格右上角 
			b[tr][tc] = *t1;
			b[tr+1][tc] = *t1;
			b[tr+1][tc+1] = *t1;
			(*t1)++; 
		}
		if( dr == tr + 1 && dc == tc)
		{
			//残缺位置在4格左下角 
			b[tr][tc] = *t1;
			b[tr][tc+1] = *t1;
			b[tr+1][tc+1] = *t1;	
			(*t1)++; 
		}
		if( dr == tr + 1 && dc == tc +1)
		{
			//残缺位置在4格右下角 
			b[tr][tc] = *t1;
			b[tr][tc+1] = *t1;
			b[tr+1][tc] = *t1;
			(*t1)++; 	
		}
/*
		for(int i = 0;i < 2*size;i++)
		{
			for(int j = 0;j < 2*size;j++)
			{
				printf("%d\t",b[i][j]); 
			}
			puts("");
		}
*/
		//printf("\ntr:%d,tc:%d----------------------\n",tr,tc);
		b[qa][qb] = 0;
		return;
	}
	else
	{
		if(dr < tr + hs && dc < tc + hs)
		{
			int tdr,tdc;
			//残缺在第二象限
			b[tr+hs-1][tc+hs] = *t1;
			b[tr+hs][tc+hs-1] = *t1;
			b[tr+hs][tc+hs] = *t1;
			(*t1)++; 
			generateBoard(tr,tc,dr,dc,hs,b,t1);
			
			tdr = tr + hs - 1;
			tdc = tc + hs; 
			generateBoard(tr,tc+hs,tdr,tdc,hs,b,t1);
			
			tdr = tr + hs;
			tdc = tc + hs - 1; 
			generateBoard(tr+hs,tc,tdr,tdc,hs,b,t1);
			
			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b,t1);
		}
		if(dr < tr + hs && dc >= tc + hs)
		{
			int tdr,tdc;
			//残缺在第一象限
			b[tr+hs-1][tc+hs-1] = *t1;
			b[tr+hs][tc+hs-1] = *t1;
			b[tr+hs][tc+hs] = *t1;
			(*t1)++; 
			generateBoard(tr,tc+hs,dr,dc,hs,b,t1);
			
			tdr = tr + hs - 1;
			tdc = tc + hs - 1; 
			generateBoard(tr,tc,tdr,tdc,hs,b,t1);
			
			tdr = tr + hs;
			tdc = tc + hs - 1; 
			generateBoard(tr+hs,tc,tdr,tdc,hs,b,t1);

			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b,t1);
		}
		if(dr >= tr + hs && dc < tc + hs)
		{
			int tdr,tdc;
			//残缺在第三象限
			b[tr+hs-1][tc+hs-1] = *t1;
			b[tr+hs-1][tc+hs] = *t1;
			b[tr+hs][tc+hs] = *t1;
			(*t1)++; 
			generateBoard(tr+hs,tc,dr,dc,hs,b,t1);
			
			tdr = tr + hs - 1;
			tdc = tc + hs - 1; 
			generateBoard(tr,tc,tdr,tdc,hs,b,t1);

			tdr = tr + hs - 1;
			tdc = tc + hs; 
			generateBoard(tr,tc+hs,tdr,tdc,hs,b,t1);
			
			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b,t1);
		}
		if(dr >= tr + hs && dc >= tc + hs)
		{
			int tdr,tdc;
			//残缺在第四象限
			b[tr+hs-1][tc+hs-1] = *t1;
			b[tr+hs-1][tc+hs] = *t1;
			b[tr+hs][tc+hs-1] = *t1;
			(*t1)++; 
			generateBoard(tr+hs,tc+hs,dr,dc,hs,b,t1);
			
			tdr = tr+hs-1;
			tdc = tc+hs-1;
			generateBoard(tr,tc,tdr,tdc,hs,b,t1);
			
			tdr = tr+hs-1;
			tdc = tc+hs;
			generateBoard(tr,tc+hs,tdr,tdc,hs,b,t1);
			
			tdr = tr+hs;
			tdc = tc+hs-1;
			generateBoard(tr+hs,tc,tdr,tdc,hs,b,t1);
		}
	} 
}
int main()
{
	//左下残缺 右下残缺 左上残缺 右上残缺
	//* *      * *        *      *
	//  *      *        * *      * *
	
	int k;
	printf("输入棋盘2^k×2^k的k值：");
	scanf("%d",&k);
	int size = mpow(2,k);
	//printf("size = %d\n",size);
	
	int *b[size]; //生成棋盘矩阵
	for(int i = 0;i < size;i++)
	{
		b[i] = (int*)malloc(sizeof(int)*size);
	}
	for(int i = 0;i < size;i++)
	{
		for(int j = 0;j < size;j++)
		{
			b[i][j] = -1;
		}
		//puts("");
	}
	
	printf("输入残缺位置（行 列）：");
	scanf("%d %d",&qa,&qb);
	int dr,dc;
	dr = qa;
	dc = qb;
	int t1 = 1; 
	
	if((qa < size && qa >= 0) && (qb < size && qb >= 0))
	{
		b[qa][qb] = 0;
		generateBoard(0,0,dr,dc,size,b,&t1);
		
		for(int i = 0;i < size;i++)
		{
			for(int j = 0;j < size;j++)
			{
				printf("%2d  ",b[i][j]); 
			}
			puts("");
		}
	}
	else
	{
		printf("残缺位置不在棋盘上，位置不合法！");
	}
	for(int i = 0;i < size;i++)
	{
		free(b[i]);
	}
	system("pause");
	return 0;
}

二、 MyCoverBoardB.c

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int qa,qb;
int mpow(int n,int k)
{
	int i;
	int t = n;
	for(i = 1; i < k;i++)
	{
		t = t * n;
	}
	return t;
}
void generateBoard(int tr,int tc,int dr,int dc,int size,int** b)
{
	int hs = size / 2;
	if(size == 2)
	{
		if( dr == tr && dc == tc )
		{
			//残缺位置在4格左上角 
			//用3号覆盖
			b[tr][tc+1] = 3;
			b[tr+1][tc] = 3;
			b[tr+1][tc+1] = 3;
		}
		if( dr== tr && dc == tc + 1)
		{
			//残缺位置在4格右上角 
			//用4号覆盖
			b[tr][tc] = 4;
			b[tr+1][tc] = 4;
			b[tr+1][tc+1] = 4;
		}
		if( dr == tr + 1 && dc == tc)
		{
			//残缺位置在4格左下角 
			//用1号覆盖
			b[tr][tc] = 1;
			b[tr][tc+1] = 1;
			b[tr+1][tc+1] = 1;	
		}
		if( dr == tr + 1 && dc == tc +1)
		{
			//残缺位置在4格右下角 
			//用2号覆盖
			b[tr][tc] = 2;
			b[tr][tc+1] = 2;
			b[tr+1][tc] = 2;	
		}
/*
		for(int i = 0;i < 2*size;i++)
		{
			for(int j = 0;j < 2*size;j++)
			{
				printf("%d\t",b[i][j]); 
			}
			puts("");
		}
*/
		//printf("\ntr:%d,tc:%d----------------------\n",tr,tc);
		b[qa][qb] = 0;
		return;
	}
	else
	{
		if(dr < tr + hs && dc < tc + hs)
		{
			int tdr,tdc;
			//残缺在第二象限
			b[tr+hs-1][tc+hs] = 3;
			b[tr+hs][tc+hs-1] = 3;
			b[tr+hs][tc+hs] = 3;
	
			generateBoard(tr,tc,dr,dc,hs,b);
			
			tdr = tr + hs - 1;
			tdc = tc + hs; 
			generateBoard(tr,tc+hs,tdr,tdc,hs,b);
			
			tdr = tr + hs;
			tdc = tc + hs - 1; 
			generateBoard(tr+hs,tc,tdr,tdc,hs,b);
			
			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b);
			
		}
		if(dr < tr + hs && dc >= tc + hs)
		{
			int tdr,tdc;
			//残缺在第一象限
			b[tr+hs-1][tc+hs-1] = 4;
			b[tr+hs][tc+hs-1] = 4;
			b[tr+hs][tc+hs] = 4;
			generateBoard(tr,tc+hs,dr,dc,hs,b);
			
			tdr = tr + hs - 1;
			tdc = tc + hs - 1; 
			generateBoard(tr,tc,tdr,tdc,hs,b);
			//generateBoard(tr,tc+hs,dr,dc,hs,b);
			
			tdr = tr + hs;
			tdc = tc + hs - 1; 
			generateBoard(tr+hs,tc,tdr,tdc,hs,b);

			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b);
		}
		if(dr >= tr + hs && dc < tc + hs)
		{
			int tdr,tdc;
			//残缺在第三象限
			b[tr+hs-1][tc+hs-1] = 1;
			b[tr+hs-1][tc+hs] = 1;
			b[tr+hs][tc+hs] = 1;
			generateBoard(tr+hs,tc,dr,dc,hs,b);
			
			tdr = tr + hs - 1;
			tdc = tc + hs - 1; 
			generateBoard(tr,tc,tdr,tdc,hs,b);

			tdr = tr + hs - 1;
			tdc = tc + hs; 
			generateBoard(tr,tc+hs,tdr,tdc,hs,b);
			//generateBoard(tr+hs,tc,dr,dc,hs,b);
			
			tdr = tr + hs;
			tdc = tc + hs; 
			generateBoard(tr+hs,tc+hs,tdr,tdc,hs,b);
		}
		if(dr >= tr + hs && dc >= tc + hs)
		{
			int tdr,tdc;
			//残缺在第四象限
			b[tr+hs-1][tc+hs-1] = 2;
			b[tr+hs-1][tc+hs] = 2;
			b[tr+hs][tc+hs-1] = 2;
			generateBoard(tr+hs,tc+hs,dr,dc,hs,b);
			
			tdr = tr+hs-1;
			tdc = tc+hs-1;
			generateBoard(tr,tc,tdr,tdc,hs,b);
			
			tdr = tr+hs-1;
			tdc = tc+hs;
			generateBoard(tr,tc+hs,tdr,tdc,hs,b);
			
			tdr = tr+hs;
			tdc = tc+hs-1;
			generateBoard(tr+hs,tc,tdr,tdc,hs,b);
			//generateBoard(tr+hs,tc+hs,dr,dc,hs,b);
		}
	} 
}
int main()
{
	//左下残缺 右下残缺 左上残缺 右上残缺
	//1 1      2 2        3      4
	//  1      2        3 3      4 4
	//把基础的四格情况分为四种样式的图形，去图形式的填充
	
	int k;
	printf("输入棋盘2^k×2^k的k值：");
	scanf("%d",&k);
	int size = mpow(2,k);
	//printf("size = %d\n",size);
	
	int *b[size]; //生成棋盘矩阵
	for(int i = 0;i < size;i++)
	{
		b[i] = (int*)malloc(sizeof(int)*size);
	}
	for(int i = 0;i < size;i++)
	{
		for(int j = 0;j < size;j++)
		{
			b[i][j] = -1;
		}
		//puts("");
	}
	
	printf("输入残缺位置（行 列）：");
	scanf("%d %d",&qa,&qb);
	int dr,dc;
	dr = qa;
	dc = qb;
	
	if((qa < size && qa >= 0) && (qb < size && qb >= 0))
	{
		b[qa][qb] = 0;
		generateBoard(0,0,dr,dc,size,b);
		
		for(int i = 0;i < size;i++)
		{
			for(int j = 0;j < size;j++)
			{
				printf("%d  ",b[i][j]); 
			}
			puts("");
		}
	}
	else
	{
		printf("残缺位置不在棋盘上，位置不合法！");
	}
	for(int i = 0;i < size;i++)
	{
		free(b[i]);
	}
	system("pause");
	return 0;
}

MyCoverBoardA.c-运行结果示例

1.k为1

   1.1缺陷在1 0位置

在这里插入图片描述

   1.2缺陷在0 0位置

在这里插入图片描述

2.k为2

   2.1缺陷在1 2位置

在这里插入图片描述

   2.2缺陷在2 3位置

在这里插入图片描述

3.k为3

   3.1缺陷在5 6位置

在这里插入图片描述

   3.1缺陷在4 2位置

在这里插入图片描述

4.k为4

4.1   3.1缺陷在12 9位置

在这里插入图片描述

MyCoverBoardB.c-运行结果示例

1.k为1

   1.2缺陷在0 0位置

在这里插入图片描述

   1.1缺陷在0 1位置

在这里插入图片描述

   1.1缺陷在1 0位置

在这里插入图片描述

   1.2缺陷在1 1位置

在这里插入图片描述

2.k为2

   2.1缺陷在1 2位置

在这里插入图片描述

   2.2缺陷在2 3位置

在这里插入图片描述

3.k为3

   3.1缺陷在5 6位置

在这里插入图片描述

   3.1缺陷在4 2位置

在这里插入图片描述

4.k为4

4.1   3.1缺陷在12 9位置

在这里插入图片描述

------------------------------------------------------第十次发项目类文章有点激动啊！-----------------------------------------------------
-----------------------------------------------------【C语言—微项目—自编练习】----------------------------------------------------------
----------------------------------------------------------------【TDTX】--------------------------------------------------------------------------

TDTX
关注
  • 15
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
棋盘覆盖问题-基于C++使用分治递归算法求解棋盘覆盖问题.zip
03-22
棋盘覆盖问题 棋盘覆盖问题_基于C++使用分治递归算法求解棋盘覆盖问题
C语言解决棋盘覆盖问题
eternitybubble的博客
07-18 1万+
棋盘覆盖问题是典型的利用分治法解决问题 把大问题分解成为相同性质的子问题 分治的技巧在于如何划分棋盘，使划分后的子棋盘的大小相同，并且每个子棋盘均包含一个特殊方格，从而将原问题分解为规模较小的棋盘覆盖问题。k&gt;0时，可将2^k×2^k的棋盘划分为4个2^（k-1）×2^（k-1）的子棋盘，如图4.11(a)所示。这样划分后，由于原棋盘只有一个特殊方格，所以，这4个子棋盘中只有一个子棋盘包...
题解 填充棋盘
yours8的博客
02-22 300
too late
棋盘覆盖问题+代码
m0_62165705的博客
08-07 503
主要介绍棋盘覆盖问题的原理及解法，其本质上是一种分治思想
c语言--分治法经典例题--求解棋盘覆盖问题
MaxDeCookies的博客
06-27 1842
有关分支经典问题期盼填充问题的一个解法
【算法】分治法的应用——棋盘覆盖问题
努力让自己的能力配得上梦想.
09-05 916
在一个2k×2k个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为特殊方格，且称该棋盘为特殊棋盘。 在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。特殊方格必位于4个较小子棋盘之一中，其余3个子棋盘中无特殊方格。为了将这3个无特殊方格的子棋盘转化为特殊棋盘，可以用一个L型骨牌覆盖这3个较小棋盘的会合处 从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种分割，直至棋盘简化为棋盘1×1
棋盘覆盖问题(L型骨牌)
todaycode
03-31 1614
#include <stdio.h> int board[8][8]; int tile=1; void chessBoard(int tr, int tc, int dr, int dc, int size) { //行列的标号从0开始使用 //tr、tc确定此时棋盘的左上角位置(tr:行号 tc:列号) //dr、dc表示此时骨牌在位置(dr,dc) // size表示...
分治法——棋盘覆盖问题/L形组件填图问题（Java实现）
qq_32792547的博客
03-26 1362
介绍分治算法的基本要素、实现步骤，以及如何利用分治法求解棋盘覆盖问题
利用分治策略实现棋盘覆盖（C语言）
weixin_63545354的博客
05-06 2698
问题描述： 在一个由✖个方格组成的棋盘中，有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。要求使用不同形态的L型骨牌（四种）覆盖给定的棋盘上除特殊方格以外的所有方格，且骨牌之间不能重叠。 概要设计：使用分治思想将问题规模缩小： ...
棋盘覆盖问题
热门推荐
acm_JL的博客
03-20 1万+
//棋盘覆盖问题 /* (tr，tc)是棋盘左上角的方格坐标 (dr,dc)是特殊方格所在的坐标 size是棋盘的行数和列数 */ #include using namespace std; int board[1025][1025]; static int tile = 1; void ChessBoard(int tr,int tc,int dr,int dc,int size) {
棋盘覆盖问题C语言实现
weixin_42575438的博客
11-16 2566
在一个2k×2k 个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构
04-07
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构 五大常用算法
C语言之整数划分问题（递归法）实例代码
08-31
主要介绍了C语言之整数划分问题（递归法）实例代码的相关资料,需要的朋友可以参考下
使用分治递归来求解棋盘覆盖问题.zip
最新发布
03-22
棋盘覆盖问题 使用分治递归来求解棋盘覆盖问题
分治法解决凸包问题（用C语言递归调用实现）
02-22
利用分治法解决凸包问题，递归调用，功能强悍，自己下载后在机器上跑一下
棋盘覆盖（C语言）
kaizitian的博客
02-06 1074
在一个×个方格组成的棋盘中，恰有一个方格与其他方格不 同，称该方格为“特殊方格”，且称该棋盘为“特殊棋盘”，在棋盘覆盖问题中，要用图1所示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 本文采用C语言进行编程，并且相信讲解了编程的思想。易懂。
分治算法——棋盘覆盖问题
weixin_45927758的博客
10-20 589
整个题目还是分治的思想，由于棋盘是2^k*2^k的，所以我们可以把他平均分成4份，每一份再递归的调用覆盖函数，直到需要覆盖的边长为1，说明只有一个位置，并且该位置放置的是特殊方格。 传入的参数中，tr，tc是棋盘的坐标，dr，dc是已经特殊方格的坐标，size是棋盘的边长。 覆盖函数的思路就是，从宏观的角度思考，把棋盘分为左上右上，左下右下，如果方格在当前的方位，就递归的覆盖棋盘，如果方格不在当前方位，就把目前围绕整个棋盘中心点的四个方格的当前方位的方格填充，并当作下一次递归的特殊方格。 #in..
分治算法---棋盘覆盖问题java代码实现
程序猿杨欣
03-17 1486
public class qipan { static int MAX_SIZE=16; static int board[][]=new int[MAX_SIZE][MAX_SIZE];     static int tile=0; public void chessboard(int tr,int tc,int dr,int dc,int size){    if(size==1)
算法设计棋盘覆盖问题c语言,棋盘覆盖问题（用分治法求解）
05-23
棋盘覆盖问题是指在一个2^n * 2^n的棋盘上，恰好有一个方格与其他方格不同，现在要用L形骨牌覆盖整个棋盘，求出最少需要多少个L形骨牌。 这个问题可以使用分治法来求解，将大问题分解成小问题来解决。具体步骤如下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值