棋盘覆盖问题c语言

合集下载

棋盘覆盖算法C#

一、实验目的：用ABCD四个字母代替四种L型骨牌，覆盖于2^kX2^k大小的棋盘中二、实验内容：在一个2^k×2^k （k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。

显然，特殊方格在棋盘中可能出现的位置有4^k种，因而有4k种不同的棋盘，图4.10(a)所示是k=2时16种棋盘中的一个。

棋盘覆盖问题（chess cover problem）要求用图4.10(b)所示的4种不同形状的L型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

三、程序设计说明：(算法设计思路)主要思路是利用递归处理棋盘，先确定每个棋盘的特殊骨牌，然后由骨牌位置确定所摆放L型骨牌的型号，依次递归所有棋盘即得其解四、程序代码（经调试正确的源程序）using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace ConsoleApplication4{class Program{static void Main(string[] args){char[,] chessboard = new char[1000,1000];int startU = 1;int endU = 4;//在这里输入棋盘的大小int startV = 1;int endV = endU;int specialU =2;int specialV = 3;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);printchessboard(startU, endU, startV, endV,specialU,specialV, chessboard);Console.ReadLine();//************1、算法没问题，程序实现有问题，增加了L型方块编码ABCD，无形中增加了难度和代码长度，全部抛弃，无法实现，虽然很蛋疼，前后花了十几个小时//************2、问题为：递归进入某函数之后无法返回跳转到上一级函数，同一级别的棋盘递归处理之后无法处理另一同级别棋盘//************3、经过逐步执行得知程序中有一处小错误，调试之后能初步输出正确答案，在4*4规模下完全正确，在8*8规模下少一块L骨牌覆盖，说明递归还是不完全//*****经过处理已经毫无错误}public static void setblock(int startU,int endU,int startV,int endV,char[,] chessboard,int specialU,int specialV ){int style;int sizeU = endU - startU + 1;int sizeV = endV - startV + 1;if(sizeU==1) return;int midU=startU+sizeU/2-1;int midV = startV + sizeV / 2 - 1;if (specialU > midU && specialV <= midV){markSpecialBlock1style1(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock2style1(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock3style1(midU, midV, chessboard, startU, endU, startV, endV);setblock(midU + 1, endU, startV, midV, chessboard, specialU, specialV);//在这里尝试修改，原始数据（midU+1, endU, midV+1, endV, chessboard, specialU, specialV），改为(midU + 1, endU, startV, midV, chessboard, specialU, specialV)//haha 终于找到了哈哈原来BUG在这里在这个判断上哈哈现在问题规模不管为多大都可以了只要不超过数组大小界限return;}if (specialU <= midU && specialV <= midV){markSpecialBlock1style2(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock2style2(midU, midV, chessboard, startU,endU, startV, endV);markSpecialBlock3style2(midU, midV, chessboard, startU, endU, startV, endV);setblock(startU, midU,startV, midV, chessboard, specialU, specialV);return;}if (specialU <= midU && specialV > midV){markSpecialBlock1style3(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock2style3(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock3style3(midU, midV, chessboard, startU, endU, startV, endV);setblock(startU, midU, midV + 1, endV, chessboard, specialU, specialV);return;}if (specialU > midU && specialV > midV){markSpecialBlock1style4(midU, midV, chessboard, startU,endU, startV, endV);markSpecialBlock2style4(midU, midV, chessboard, startU, endU, startV, endV);markSpecialBlock3style4(midU, midV, chessboard, startU, endU, startV, endV);setblock(midU + 1, endU, midV + 1, endV, chessboard, specialU, specialV);return;}}/*public static void isWhatStyle(int specialU,int specialV,int midU,int midV,out int style){if (specialU > midU && specialV <= midV)style = 1;else if (specialU <= midU && specialV <= midV)style = 2;else if (specialU <= midU && specialV > midV)style = 3;elsestyle = 4;return;}*///********define style1public static void markSpecialBlock1style1(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;//防止在棋盘中进行无限制的覆盖if (specialU >= startU && specialU <= midU && specialV >= startV && specialV <= midV)//{chessboard[specialU, specialV] = 'A';startU = startU;endU = midU;startV = startV;endV = midV;setblock(startU,endU,startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock2style1(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV+1;if (chessboard[specialU, specialV] != 0) return;if (specialU >= startU && specialU <= midU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'A';startU = startU;endU = midU;startV = midV+1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock3style1(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU + 1;int specialV = midV + 1;if (chessboard[specialU, specialV] != 0) return;if(specialU >= midU + 1 && specialU <= endU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'A';startU = midU+1;endU = endU;startV = midV + 1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}//********define style2public static void markSpecialBlock1style2(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU+1;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;if (specialU >= midU + 1 && specialU <= endU && specialV >= startV && specialV <= midV){chessboard[specialU, specialV] = 'B';startU = midU+1;endU = endU;startV = startV;endV = midV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock2style2(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV + 1;if (chessboard[specialU, specialV] != 0) return;if (specialU >= startU && specialU <= midU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'B';startU = startU;endU = midU;startV = midV + 1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock3style2(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU + 1;int specialV = midV + 1;if (chessboard[specialU, specialV] != 0) return;if (specialU >= midU + 1 && specialU <= endU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'B';startU = midU + 1;endU = endU;startV = midV + 1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}//********define style3public static void markSpecialBlock1style3(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;if (specialU >= startU && specialU <= midU && specialV >= startV && specialV <= midV){chessboard[specialU, specialV] = 'C';startU = startU;endU = midU;startV = startV;endV = midV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock2style3(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU + 1;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;if (specialU >= midU + 1 && specialU <= endU && specialV >= startV && specialV <= midV){chessboard[specialU, specialV] = 'C';startU = midU+1;endU = endU;startV = startV;endV = midV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock3style3(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU + 1;int specialV = midV + 1;if (chessboard[specialU, specialV] != 0) return;if (specialU >= midU + 1 && specialU <= endU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'C';startU = midU + 1;endU = endU;startV = midV + 1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}//********define style4public static void markSpecialBlock1style4(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;if (specialU >= startU && specialU <= midU && specialV >= startV && specialV <= midV){chessboard[specialU, specialV] = 'D';startU = startU;endU = midU;startV = startV;endV = midV;setblock(startU, endU, startV, endV, chessboard, specialU,specialV);}}public static void markSpecialBlock2style4(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU;int specialV = midV + 1;if (chessboard[specialU, specialV] != 0) return;if (specialU >= startU && specialU <= midU && specialV >= midV + 1 && specialV <= endV){chessboard[specialU, specialV] = 'D';startU = startU;endU = midU;startV = midV + 1;endV = endV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}public static void markSpecialBlock3style4(int midU, int midV, char[,] chessboard, int startU, int endU, int startV, int endV){int specialU = midU + 1;int specialV = midV;if (chessboard[specialU, specialV] != 0) return;if (specialU >= midU + 1 && specialU <= endU && specialV >= startV && specialV <= midV){chessboard[specialU, specialV] = 'D';startU = midU + 1;endU = endU;startV = startV;endV = midV;setblock(startU, endU, startV, endV, chessboard, specialU, specialV);}}//*********print chessboardpublic static void printchessboard(int startU,int endU,int startV,int endV,int specialU,int specialV,char[,] chessboard){for (int i = startV; i <= endV; i++){for (int j = startU; j <= endU; j++){if(j==specialU&&i==specialV)Console.Write('S'+" ");elseConsole.Write(chessboard[j, i]+" ");}Console.WriteLine();}}}}五．程序运行结果（测试数据和运行结果）。

棋盘覆盖问题程序说明

棋盘覆盖问题
对一M*N棋盘，假设有外形完全一样的骨排.每一骨排可覆盖棋盘上两相邻的方格.若用一些骨排覆盖棋盘,使棋盘上所有格被盖,且不交叉,称完全覆盖,.8*8棋盘是否可以完全覆盖?
编程思想：将棋盘设为一个M*N数组，对数组中每个元素分别赋值0和1，并使每个元素与其周围元素的值不相等。

再将数组中对角元素赋给0，1以外的值。

统计数组中0元素与1元素的个数。

若相等，证明可以完全覆盖，不相等则不能完全覆盖。

本程序特点：棋盘的行数和列数可以是任意的。

只需输入行数和列数便可得到结论。

缺点：棋盘只能是缺少对角的，不能是缺少任意的几格。

棋盘覆盖问题..txt - 记事本

#include <iostream>using namespace std;#define SIZE 4int title = 1; //title表示L型骨牌的编号int board[SIZE][SIZE];void ChessBoard(int tr,int tc,int dr,int dc,int size);void ChessPrint();int main(int argc,char * argv[]){char again = 'Y';int dr,dc;while(again=='Y'||again=='y'){cout<<"输入特殊方格所在的行号dr和列号dc：";cin>>dr>>dc;ChessBoard(0,0,dr-1,dc-1,SIZE);cout<<"覆盖结果为："<<endl;ChessPrint();cout<<"继续？（Y||y）";cin>>again;}return 0;}/*** 功能：棋盘覆盖* @param tr表示棋盘左上角行号* @param tc表示棋盘左上角列号* @param dr表示特殊棋盘的行号* @param dc表示特殊棋盘的列号* @param size = 2^k* 棋盘的规格为2^k * 2^k**/void ChessBoard(int tr,int tc,int dr,int dc,int size){if(1 == size) return;int t = title++; //L型骨牌号int s = size / 2; //分割棋盘//覆盖左上角子棋盘if(dr < tr + s && dc < tc + s)//特殊方格在此棋盘中ChessBoard(tr, tc, dr, dc, s);else{//此棋盘无特殊方格//用t号L型骨牌覆盖右下角board[tr + s - 1][tc + s - 1] = t;//覆盖其余方格ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);}//覆盖右上角if(dr < tr + s && dc >= tc + s)//特殊方格在此棋盘中ChessBoard(tr, tc + s, dr, dc, s);第 1 页else{//此子棋盘中无特殊方格//用t号L型骨牌覆盖左下角board[tr + s - 1][tc + s] = t;//覆盖其余方格ChessBoard(tr, tc + s, tr + s - 1, tc + s, s); }//覆盖左下角子棋盘if(dr >= tr + s && dc < tc + s)//特殊方格在此棋盘中ChessBoard(tr + s, tc, dr, dc, s);else{//用t号L型骨牌覆盖右上角board[tr + s][tc + s -1] = t;//覆盖其余方格ChessBoard(tr + s, tc, tr + s, tc + s - 1, s); }//覆盖右下角子棋盘if(dr >= tr + s && dc >= tc + s)//特殊方格在此棋盘中ChessBoard(tr + s, tc + s, dr, dc, s);else{//用t号L型骨牌覆盖左上角board[tr + s][tc + s] = t;//覆盖其余方格ChessBoard(tr + s, tc + s, tr + s, tc + s, s); }}//打印void ChessPrint(){int i;int j;for(i = 0; i < SIZE; i++){for(j = 0; j < SIZE; j++){cout<<board[i][j]<<" ";}cout<<endl;}}第 2 页。

c语言课程设计棋盘

c语言课程设计棋盘一、教学目标本节课的学习目标包括以下三个方面：1.知识目标：学生需要掌握C语言的基本语法和编程技巧，了解棋盘游戏的原理和设计方法。

2.技能目标：学生能够运用C语言编写简单的棋盘游戏，提高编程能力和问题解决能力。

3.情感态度价值观目标：培养学生对计算机科学的兴趣，增强创新意识和团队合作精神。

二、教学内容本节课的教学内容主要包括以下几个部分：1.C语言基本语法和编程技巧：数据类型、变量、运算符、控制结构等。

2.棋盘游戏的原理和设计方法：棋盘的表示方法、游戏规则的制定、玩家交互等。

3.棋盘游戏的编程实现：编写游戏主函数、调用游戏功能函数、处理玩家输入等。

三、教学方法为了实现本节课的教学目标，我们将采用以下几种教学方法：1.讲授法：讲解C语言基本语法和编程技巧，引导学生掌握棋盘游戏的原理。

2.案例分析法：分析经典棋盘游戏案例，让学生了解游戏设计的方法和技巧。

3.实验法：让学生动手编写棋盘游戏，培养实际编程能力和问题解决能力。

4.小组讨论法：分组进行游戏设计，鼓励学生互相交流、合作，提高团队合作精神。

四、教学资源为了支持本节课的教学内容和教学方法的实施，我们将准备以下教学资源：1.教材：《C语言程序设计》等相关教材，为学生提供理论知识的学习材料。

2.参考书：《C语言编程实例教程》等参考书，为学生提供更多的学习资源。

3.多媒体资料：制作课件和教学视频，为学生提供直观的学习体验。

4.实验设备：计算机、编程环境等，为学生提供实践操作的平台。

五、教学评估本节课的评估方式包括以下几个方面：1.平时表现：通过课堂参与、提问、讨论等方式评估学生的学习态度和积极性。

2.作业：布置相关的编程作业，评估学生的理解和应用能力。

3.考试：进行期中和期末考试，全面评估学生的知识掌握和编程能力。

评估方式应客观、公正，能够全面反映学生的学习成果。

同时，注重鼓励学生的创新和团队合作精神。

六、教学安排本节课的教学安排如下：1.教学进度：按照教材的章节和教学大纲进行教学，确保完成教学任务。

棋盘覆盖(分治法)

printf("size=%d;\n");
}
/*left,top：方块的左上角坐标，x,y：特殊方块的坐标 size:当前的子棋盘大小*/
void ChessBoard(int left,int top,int x,int y,int size)
{
int i,t,s,pos;/*t是方块的编号，s是棋盘的一半尺寸！(size/2),pos表示方块位于哪一角 */
scanf("%d",&y);
if(k<0 || k>6 || x<0 || x>(size-1) || y<0 || y>(size-1))
{
printf("Input invalid!\n");
return;
}
InitGraph();
{
for(i=0;i<size;i++)
{
printf("%2d ",Board[i][j]);
}
printf("\n");
}
printf("\n--------------------------------\n");
{
setfillstyle(SOLID_FILL,color);
rectangle(BoardLeft+x*CellSize,BoardTop+y*CellSize,BoardLeft+(x+1)*CellSize,BoardTop+(y+1)*CellSize);
floodfill(BoardLeft+x*CellSize+CellSize/2,BoardTop+y*CellSize+CellSize/2,BorderColor);

棋盘算法实验报告(3篇)

个人自我介绍简单大方
很抱歉，但我无法为您提供____字的自我介绍。

以下是一个简洁而大方的自我介绍示例，供您参考：
大家好，我叫[姓名]。

很高兴有机会向大家介绍一下自己。

我出生并长大在[所在地]，是一个勤奋、积极向上的人。

在学业方面，我于[毕业时间]从[学校名称]获得了[学位/专业]学位。

在大学期间，我通过自我努力和课外学习，取得了良好的学术成绩，并参与了一些学生组织和社团活动。

这些经历不仅培养了我的团队合作和领导能力，也加强了我的沟通和组织能力。

在工作方面，我有[工作年限]年的相关工作经验。

我曾在[公司/组织名称]担任[职位]，负责[工作职责]。

在这期间，我不断努力提升自己的专业知识和技能，以适应快速发展的工作环境。

我善于分析问题并找出解决方案，能够有效地与团队合作并承担责任，这些都为我赢得了同事和上级的认可。

除了工作，我也积极参与志愿者活动，希望能为社区和弱势群体做一点贡献。

我相信，通过奉献和关心他人，我们可以建立一个更加和谐和温暖的社会。

在个人生活中，我喜欢阅读、旅行和运动。

阅读扩展了我的视野，旅行让我能够体验不同的文化和风景，而运动则让我保持健康和积极的精神状态。

此外，我也很喜欢与家人和朋友相处，分享彼此的喜怒哀乐。

总的来说，我是一个热情、乐观、有责任心的人。

我相信勤奋和坚持可以取得成功，而真诚和善良可以赢得他人的信任和支持。

我希望能够在您的团队中发挥我的才能，并与大家一同成长和进步。

这就是我简单的自我介绍，谢谢大家！。

用分治法求解棋盘覆盖问题

棋盘覆盖问题问题描述：在一个2k×2k（k≥0)个方格组成的棋盘中,恰有一个方格与其他方格不同，称该方格为特殊方格.显然，特殊方格在棋盘中出现的位置有4k中情形，因而有4k中不同的棋盘，图（a）所示是k=2时16种棋盘中的一个。

棋盘覆盖问题要求用图（b）所示的4中不同形状的L型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且热河亮哥L型骨牌不得重复覆盖.问题分析：K〉0时，可将2k×2k的棋盘划分为4个2k-1×2k-1的子棋盘。

这样划分后,由于原棋盘只有一个特殊方格，所以，这4个子棋盘中只有1个子棋盘中有特殊方格，其余3个子棋盘中没有特殊方格。

为了将这3个没有特殊方格的子棋盘转化成为特殊棋盘，以便采用递归方法求解，可以用一个L型骨牌覆盖这3个较小的棋盘的会合处，从而将原问题转化为4个较小规模的棋盘覆盖问题。

递归地使用这种划分策略，直至将棋盘分割为1×1的子棋盘。

问题求解：下面介绍棋盘覆盖问题中数据结构的设计。

（1）棋盘:可以用一个二维数组board[size］[size］表示一个棋盘,其中size=2k。

为了在递归处理的过程中使用同一个棋盘，将数组board设为全局变量。

（2）子棋盘：整个棋盘用二维数组board[size］［size]表示，其中的子棋盘由棋盘左上角的下标tr、tc和棋盘大小s表示。

（3）特殊方格：用board[dr］［dc］表示特殊方格，dr和dc是该特殊方格在二维数组board中的下标。

（4）L型骨牌：一个2k×2k的棋盘中有一个特殊方格，所以，用到L型骨牌的个数为(4k-1）/3，将所有L型骨牌从1开始连续编号，用一个全局变量tile表示。

图(a)C语言源码：/*author: 彭洪伟*studentID：0950310006＊class:计科1班*problem：分治法解决棋盘覆盖问题*/#include <stdio.h>＃include 〈math.h〉int tile=1; //记录骨牌的型号int board[20]［20]={0｝; //存储棋盘被覆盖的情况void ChessBoard（int tr，int tc,int dr，int dc，int size）{ //tr和tc是棋盘左上角的下标,dr和dc是特殊方格的下标，size是棋盘的大小int t=0;int s；if (size==1）return;t=tile++;s=size/2； //划分棋盘//覆盖左上角棋盘if (dr〈tr+s&＆dc〈tc+s） //特殊方格在棋盘的左上角ChessBoard（tr,tc，dr，dc,s）;else｛board[tr+s-1］[tc+s—1］=t；ChessBoard（tr，tc,tr+s—1，tc+s—1，s）；｝//覆盖右上角棋盘if （dr<tr+s＆&dc>=tc+s) //特殊方格在棋盘的右上角ChessBoard（tr，tc+s,dr，dc，s）;else{board［tr+s—1]［tc+s］=t;ChessBoard(tr，tc+s,tr+s—1，tc+s，s);}//覆盖左下角棋盘if （dr>=tr+s＆＆dc<tc+s）//特殊方格在棋盘的左下角ChessBoard(tr+s,tc，dr,dc，s);else｛board[tr+s][tc+s—1］=t;ChessBoard（tr+s，tc,tr+s,tc+s—1，s）;}//覆盖右下角棋盘if (dr>=tr+s&＆dc〉=tc+s) //特殊方格在棋盘的右下角ChessBoard(tr+s,tc+s，dr，dc，s);else｛board［tr+s][tc+s］=t；ChessBoard（tr+s，tc+s，tr+s，tc+s,s);｝}int main（）｛int k，x，y;printf（"请输入棋盘的规模K：")；scanf("%d”,＆k);printf（"请输入特殊方格的下标x,y:"）;scanf（"%d %d”,&x，&y）；ChessBoard(0,0,x，y，pow（2，k))；for(int i=0; i〈pow(2,k)； i++）｛for (int j=0； j<pow(2，k); j++){printf(”％—4d"，board［i]［j］)；｝printf("\n”）;}return 0;｝运行结果截图：。

棋盘覆盖问题的算法实现(代码及截图)

if(dr>=tr+s &&dc<tc+s) ChessBoard(tr+s,tc,dr,dc,s); else{ Board[tr+s][tc+s-1]=t; ChessBoard(tr+s,tc,tr+s,tc+s-1,s); } if(dr>=tr+s &&dc>=tc+s) ChessBoard(tr+s,tc+s,dr,dc,s); else{ Board[tr+s][tc+s]=t; ChessBoard(tr+s,tc+s,tr+s,tc+s,s); } } void main() { int i,j,k,a,b; printf("请输入特殊方格的坐标："); scanf("%d %d",&a,&b); ChessBoard(0,0,a,b,4); for(k=0;k<tile;k++) { printf("编号为%d的型骨牌的坐标为：",k); for(i=0;i<4;i++) for(j=0;j<4;j++) { if(Board[i][j]==k&&(i!=a||j!=b)) printf("(%d,%d)",i,j); } printf("\n"); } }
棋盘覆盖问题的算法实现
在一个2^k * 2^k个方格组成的棋盘中，有一个方格与其它的不同，若使用以下四种L型骨牌覆盖除这个特殊方格的其它方格，如何覆盖。四个L型骨牌如下图1

算法实验报告--棋盘覆盖

算法分析与设计实验报告实验名称：棋盘覆盖实验日期： 2011/03/06 学生姓名：学生学号：一、实验目的在一个2^k*2^k的方格组成的棋盘中，若恰有一个方格与其他方格不同，则称该方格为一个特殊方格。

用分治法将整个棋盘除特殊方格以外的方格覆盖。

二、实验环境Windows7 + Visual Studio 2010三、实验内容1.设计思路当k>0时，将2k * 2k的棋盘分割为4个2（k-1）*2（k-1）子棋盘。

特殊方格必位于4个较小棋盘之一中，其余3个子棋盘中无特殊方格。

为了将这3个无特殊方格的子棋盘化为特殊棋盘，我们用一个L型骨牌覆盖这3个较小的棋盘的回合处，这3个子棋盘被L型骨牌覆盖的方格就成为该棋盘上的特殊方格，从而将原问题化为4个小规模的棋盘覆盖问题。

递归地使用这种分割，直至棋盘化简为1*1棋盘。

2.相关模块#include<iostream>#include<iomanip>using namespace std;void ChessBoard(int,int,int,int,int);int **board;//棋盘int tile = 1;//L型骨牌编号void main(){int size = 0;int row, column;cout << "Input the size n of the chessboard(n*n): "<< endl;cin >> size;cout << "Input the position of the special check: " << endl;cin >> row >> column;board = new int*[size];for(int i=0; i<size; ++i){board[i] = new int[size];for(int j=0;j<size;++j)board[i][j] = 0;}ChessBoard(0,0,row,column,size);cout << "Output the chessboard(0 represents the special one): " << endl;for(int i=0; i<size; ++i){for(int j=0; j<size; ++j)cout << setw(2) << board[i][j] << " ";cout << endl;}for(int j=0; j<size; ++j)delete []board[j];delete []board;system("pause");}void ChessBoard(int tr,int tc,int dr,int dc,int size){//tr:左上角行号//tc:左上角列号//dr:特殊方格行号//dr:特殊方格列号if(size == 1)return;int t = tile++,//L型骨牌号s = size/2;//分割棋盘//覆盖左上角棋牌if(dr<tr+s && dc<tc+s)//特殊方格在此棋盘中ChessBoard(tr,tc,dr,dc,s);else{//子棋牌中无特殊方格//用号型骨牌覆盖右下角board[tr+s-1][tc+s-1] = t;//覆盖其余方格ChessBoard(tr,tc,tr+s-1,tc+s-1,s);}//右上角if(dr<tr+s && dc>=tc+s)ChessBoard(tr,tc+s,dr,dc,s);else{board[tr+s-1][tc+s]=t;ChessBoard(tr,tc+s,tr+s-1,tc+s-1,s);}//左下角if(dr>=tr+s && dc<tc+s)ChessBoard(tr+s,tc,dr,dc,s);else{board[tr+s][tc+s-1]=t;ChessBoard(tr+s,tc,tr+s,tc+s-1,s);}//右下角if(dr>=tr+s && dc>=tc+s)ChessBoard(tr+s,tc+s,dr,dc,s);else{board[tr+s][tc+s]=t;ChessBoard(tr+s,tc+s,tr+s,tc+s,s);}}四、实验结果分析及结论由于覆盖一个2k * 2k棋盘所需的L型骨牌个数为（4k-1）/3，故此算法是一个在渐近意义下最优的算法。

循环赛日程表棋盘覆盖问题

}
//覆盖左下角子棋盘
if (dr >= tr + s && dc < tc + s) //特殊方格在此棋盘中
chessBoard(tr+s, tc, dr, dc, s);
else //此棋盘中无特殊方格
{
board[tr + s][tc + s - 1] = t; //用t号L型骨牌覆盖右上角
chessBoard(tr+s, tc, tr+s, tc+s-1, s);//覆盖其余方格
实验地点：信息楼215
所使用的工具软件及环境：Microsoft Visual Studio 2010
一、实验要求：
项目一：循环赛日程表问题
1．了解程序的执行过程，正确分析算法时间复杂性；
2．完成代码编写，调试正确
3．对n=8，n=11进行测试。
项目二：棋盘覆盖问题求解
1．了解程序的执行过程，正确分析算法时间复杂性；
{
b[i] = m+i;
b[m+i] = b[i];
}
for(int i = 1; i<=m; i++)
{
for(int j=1; j<=m+1; j++)
{
if(a[i][j] > m)
{
a[i][j] = b[i];
a[m+i][j] = (ห้องสมุดไป่ตู้[i] + m)%n;
}
else
a[m+i][j] = a[i][j] + m;
按此要求可将比赛日程表设计成有n行和n-1列的表。在表中第i行和第j列处填入第i个选手在第j天所遇到的选手。按分治策略，可以将所有选手对分为两半，n个选手的比赛日程表就可以通过为n/2个选手设计的比赛日程表来决定。递归地用这种一分为二的策略对选手进行分割，直到只剩下两个选手时，比赛日程表的制定就变得很简单，这时只要让这两个选手进行比赛就可以了。

棋盘覆盖问题 C语言

printf("输入特殊方格位置：row,col \n");
scanf("%d,%d",&row,&col);//输入特殊方格位置
ChessBoard(0,0,row,col,size);
printf("输出棋盘覆盖结果：\n");
for (r = 0; r < size; r++)//输出棋盘覆盖结果
{
if(size==1) return;//递归边界
int t=tile++;//L型骨牌号
int s=size/2;//分割棋盘
//覆盖左上角子棋盘
if(dr<tr+s&&dc<tc+s)
// 特殊方格在此棋盘中
ChessBoard(tr,tc,dr,dc,s);
else
{ //此棋盘中无特殊方格 ,用t号L型骨牌覆盖右下角
实验报告
学号
54141325ห้องสมุดไป่ตู้107
姓名
高行行
专业班级
移动互联网14-01
课程
算法分析与设计
实验日期
2016.9.29
实验时间
8:00-9:00
实验情况
备注
棋盘覆盖问题算法：
#include<stdio.h>
int tile=1;
int board[100][100];
void ChessBoard(int tr,int tc,int dr,int dc,int size)
board[tr+s][tc+s-1]=t;
// 覆盖本子棋盘中的其余方格

关于棋盘覆盖问题的算法(C++) [当文网提供]

分治法解决棋盘覆盖问题By Aillo on April 9, 2008 10:22 PM |0 Comments | Previous | Next | EDIT在一个2k x 2k ( 即：2^k x 2^k )个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。

在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

这里我们用分治法解决该问题。

分治法是把一个规模很大的问题分解为多个规模较小、类似的子问题，然后递归地解决所有子问题，最后再由子问题的解决得到原问题的解决。

【解题思路】：将2^k x 2^k的棋盘，先分成相等的四块子棋盘，其中特殊方格位于四个中的一个，构造剩下没特殊方格三个子棋盘，将他们中的也假一个方格设为特殊方格。

如果是：左上的子棋盘（若不存在特殊方格）----则将该子棋盘右下角的那个方格假设为特殊方格右上的子棋盘（若不存在特殊方格）----则将该子棋盘左下角的那个方格假设为特殊方格左下的子棋盘（若不存在特殊方格）----则将该子棋盘右上角的那个方格假设为特殊方格右下的子棋盘（若不存在特殊方格）----则将该子棋盘左上角的那个方格假设为特殊方格当然上面四种，只可能且必定只有三个成立，那三个假设的特殊方格刚好构成一个L型骨架，我们可以给它们作上相同的标记。

这样四个子棋盘就分别都和原来的大棋盘类似，我们就可以用递归算法解决。

代码如下：#include<iostream.h>int tile=1;int board[100][100];void chessBoard(int tr, int tc, int dr, int dc, int size) {if(size==1)return;int t=tile++;int s=size/2;if(dr<tr+s && dc<tc+s)chessBoard(tr, tc, dr, dc, s);else{board[tr+s-1][tc+s-1]=t;chessBoard(tr, tc, tr+s-1, tc+s-1, s);}if(dr<tr+s && dc>=tc+s)chessBoard(tr, tc+s, dr, dc, s);else{board[tr+s-1][tc+s]=t;chessBoard(tr, tc+s, tr+s-1, tc+s, s);}if(dr>=tr+s && dc<tc+s)chessBoard(tr+s, tc, dr, dc, s);else{board[tr+s][tc+s-1]=t;chessBoard(tr+s, tc, tr+s, tc+s-1, s);}if(dr>=tr+s && dc>=tc+s)chessBoard(tr+s, tc+s, dr, dc, s);else{board[tr+s][tc+s]=t;chessBoard(tr+s, tc+s, tr+s, tc+s, s);}}void main(){int size;cout<<"输入棋盘的size(大小必须是2的n次幂): ";cin>>size;int index_x,index_y;cout<<"输入特殊方格位置的坐标: ";cin>>index_x>>index_y;chessBoard(0,0,index_x,index_y,size);for(int i=0;i<size;i++){for(int j=0;j<size;j++)cout<<board[i][j]<<"\t";cout<<endl;}}关于棋盘覆盖问题的算法(C++)//程序说明：1):讲一下代码拷贝到vc6.0(或其他支持的IDE环境)下，执行后会生成一个// input.txt文件，打开将里面的参数换成你想设计的再执行程序就OK了！// 2):如果对代码理解不透，建议使用但不调试，检测每一步的执行情况// 3):本程序仅供学习参考使用，用完请删除#include<stdio.h>#include<fstream.h>#include<iomanip.h>#include<iostream.h>#include<stdlib.h>int tile=0; //定义全局变量tile表示L型骨牌编号int **chessarr; //定义全局变量chessarr表示棋盘数组void chessboard(int row0,int col0,int size,int sprow,int spcol);// 棋盘覆盖函数// row0,col0为棋盘左上角位置，sprow,spcol为特殊方格位置// size为棋盘规模void chessboard(int row0,int col0,int size,int sprow,int spcol) //棋盘覆盖函数{if(size==1) return; //如果棋盘规模=1，返回int s=size/2; //分割棋盘int t=++tile; //L型骨牌编号加1//处理左上角子棋盘if(sprow < row0+s && spcol < col0+s)chessboard(row0,col0,s,sprow,spcol);else{chessarr[row0+s-1][col0+s-1]=t;chessboard(row0,col0,s,row0+s-1,col0+s-1);}//处理右上角子棋盘if(sprow < row0+s && spcol >= col0+s)chessboard(row0,col0+s,s,sprow,spcol);else{chessarr[row0+s-1][col0+s]=t;chessboard(row0,col0+s,s,row0+s-1,col0+s);}//处理左下角子棋盘if(sprow >= row0+s && spcol < col0+s)chessboard(row0+s,col0,s,sprow,spcol);else{chessarr[row0+s][col0+s-1]=t;chessboard(row0+s,col0,s,row0+s,col0+s-1);}//处理右下角子棋盘if(sprow >= row0+s && spcol >= col0+s)chessboard(row0+s,col0+s,s,sprow,spcol);else{chessarr[row0+s][col0+s]=t;chessboard(row0+s,col0+s,s,row0+s,col0+s);}}void main(){int k,x,y; //阶数及特殊点位置int i,j,n; //棋盘规模为n*nifstream in("input.txt"); //打开输入文件if(in.fail()){cout << "the input.txt is not exist!";exit(1);}in>>k>>x>>y; //读入阶数k和特殊方格位置in.close(); //关闭输入文件if (k<1){cout << "K<1, Error input.txt!";exit (1);}for (i=0,n=1;i<k;i++)n*=2;//在堆内存中建立棋盘数组，填充特殊方格if((chessarr=new int*[n])==NULL){cout << "Can't allocate more memory,terminating." << endl;exit (1);}for (i=0;i<n;i++ ){if((chessarr[i]=new int[n])==NULL){cout << "Can't allocate more memory,terminating." << endl;exit (1);}}chessarr[x-1][y-1]=0; // 填写特殊方格tile=0;chessboard(0,0,n,x-1,y-1);//进行棋盘覆盖,左上角位置0,0; 棋盘宽度n; 特殊点x,y ofstream out("output.txt"); //创建输出文件//同时输出到文件和屏幕for (i=0;i<n;i++){for (j=0;j<n;j++ ){out << setw(5) << chessarr[i][j];cout << setw(5) << chessarr[i][j];}out << endl;cout << endl;}out.close(); //关闭输出文件//释放内存for(i=0;i<n;i++)delete[] chessarr[i];delete[] chessarr;return;}矩阵快速乘法矩阵相乘在3D变换中是被频繁用到的一种计算，但在矩阵相乘过程中用到了大量的乘法运算，而cpu中运算单元对于乘法的效率是比较低的，远低于加法运算，所以，如果能找到一种用加法来替代乘法的方法实现矩阵相乘，将能大大提高我们程序的效率。

棋盘覆盖问题描述与实现

棋盘覆盖问题【问题】在一个2k×2k （k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。

显然，特殊方格在棋盘中可能出现的位置有4k 种，因而有4k种不同的棋盘，图4.10(a)所示是k=2时16种棋盘中的一个。

棋盘覆盖问题（chess cover problem）要求用图4.10(b)所示的4种不同形状的L 型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

【想法】如何应用分治法求解棋盘覆盖问题呢？分治的技巧在于如何划分棋盘，使划分后的子棋盘的大小相同，并且每个子棋盘均包含一个特殊方格，从而将原问题分解为规模较小的棋盘覆盖问题。

k>0时，可将2k×2k的棋盘划分为4个2k-1×2k-1的子棋盘，如图4.11(a)所示。

这样划分后，由于原棋盘只有一个特殊方格，所以，这4个子棋盘中只有一个子棋盘包含该特殊方格，其余3个子棋盘中没有特殊方格。

为了将这3个没有特殊方格的子棋盘转化为特殊棋盘，以便采用递归方法求解，可以用一个L型骨牌覆盖这3个较小棋盘的会合处，如图4.11(b)所示，从而将原问题转化为4个较小规模的棋盘覆盖问题。

递归地使用这种划分策略，直至将棋盘分割为1×1的子棋盘。

算法实现：#include <stdio.h>#include <stdlib.h>#define N 100int board[N][N];int t;void chessBoard(int tr, int tc, int dr, int dc, int size){int s, t1; //t1表示本次覆盖所用L型骨牌的编号if (size == 1) return; //棋盘只有一个方格且是特殊方格t1 = ++t; // L型骨牌编号s = size/2; // 划分棋盘if (dr < tr + s && dc < tc + s) //特殊方格在左上角子棋盘中chessBoard(tr, tc, dr, dc, s); //递归处理子棋盘else{ //用t1号L型骨牌覆盖右下角，再递归处理子棋盘board[tr + s - 1][tc + s - 1] = t1;chessBoard(tr, tc, tr+s-1, tc+s-1, s);}if (dr < tr + s && dc >= tc + s) //特殊方格在右上角子棋盘中chessBoard(tr, tc+s, dr, dc, s); //递归处理子棋盘else { //用t1号L型骨牌覆盖左下角，再递归处理子棋盘board[tr + s - 1][tc + s] = t1;chessBoard(tr, tc+s, tr+s-1, tc+s, s);}if (dr >= tr + s && dc < tc + s) //特殊方格在左下角子棋盘中chessBoard(tr+s, tc, dr, dc, s); //递归处理子棋盘else { //用t1号L型骨牌覆盖右上角，再递归处理子棋盘board[tr + s][tc + s - 1] = t1;chessBoard(tr+s, tc, tr+s, tc+s-1, s);}if (dr >= tr + s && dc >= tc + s) //特殊方格在右下角子棋盘中chessBoard(tr+s, tc+s, dr, dc, s); //递归处理子棋盘else { //用t1号L型骨牌覆盖左上角，再递归处理子棋盘board[tr + s][tc + s] = t1;chessBoard(tr+s, tc+s, tr+s, tc+s, s);}}void print(int n){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)if(j==n-1){printf("%d\n",board[i][j]);}else{printf("%d,",board[i][j]);}}}void main(){int tr,tc,dr,dc,size;tr=0;tc=0;printf("输入棋盘大小:");scanf("%d",&size);printf("输入特殊棋盘位置,如输入：1,1：");scanf("%d,%d",&dr,&dc);board[dr-1][dc-1]=0;chessBoard(tr,tc,dr-1,dc-1,size);print(size);}。

棋盘覆盖问题和快速排序问题

21. Matrix[tr + s - 1][tc + s - 1] = t;22. chessBoard(tr, tc, tr + s - 1, tc + s - 1, s);23. }24.if (dr < tr + s && dc >= tc + s)25. {26. chessBoard(tr, tc + s, dr, dc, s);27. }28.else29. {30. Matrix[tr + s - 1][tc + s] = t;31. chessBoard(tr, tc + s, tr + s - 1, tc + s, s);32. }33.if (dr >= tr + s && dc < tc + s)34. {35. chessBoard(tr + s, tc, dr, dc, s);36. }37.else38. {39. Matrix[tr + s][tc + s - 1] = t;40. chessBoard(tr + s, tc, tr + s, tc + s - 1, s);41. }42.if (dr >= tr + s && dc >= tc + s)43. {44. chessBoard(tr + s, tc + s, dr, dc, s);45. }46.else47. {48. Matrix[tr + s][tc + s] = t;49. chessBoard(tr + s, tc + s, tr + s, tc + s, s);50. }51.}52.53.int main()54.{55.int size, r, c, row, col;56. printf("请输入棋盘的行列号");57. scanf("%d", &size);58. printf("请输入特殊方格的行列号");59. scanf("%d %d", &row, &col);60. chessBoard(0, 0, row, col, size);61.62.for (r = 0; r < size; r++)63. {64.for (c = 0; c < size; c++)65. {66. printf("%2d ", Matrix[r][c]);67. }68. printf("\n");69. }70.71. system("pause");72.73.return 0;74.}//快速排序算法代码1.#include<bits/stdc++.h>ing namespace std;3.int partition(vector<int> &vi, int low, int up)4.{5.int pivot = vi[up];6.int i = low - 1;7.for (int j = low; j < up; j++)8. {9.if (vi[j] <= pivot)10. {11. i++;12. swap(vi[i], vi[j]);13. }14. }15. swap(vi[i + 1], vi[up]);16.return i + 1;17.}18.void quickSort(vector<int> &vi, int low, int up)19.{20.if (low < up)21. {22.int mid = partition(vi, low, up);23. quickSort(vi, low, mid - 1);24. quickSort(vi, mid + 1, up);25. }26.}27.void qSort(vector<int> &vi)28.{29. quickSort(vi, 0, vi.size() - 1);30.}31.32.int main()33.{34.int a[99999];35.int max = 100000, min = 0;36. srand((unsigned)time(NULL));37.for (int i = 0; i < 10000; i++) {38. a[i] = rand() % (int)(max - min + 1) + min;39. }40. vector<int> va(a, a + 9999);41.42. cout << "Before quicksort:\n";43.for (auto x : va)44. cout << x << " ";45. cout << endl;46.47. qSort(va);48.49. cout << "After quicksort:\n";50.for (auto x : va)51. cout << x << " ";52. cout << endl;53. system("pause");54.return 0;55.}四、程序测试//棋盘覆盖算法//快速排序算法//棋盘覆盖算法//快速排序算法随机生成数（N=10K）：排序结果：解：=+-=)1()1(4)(O k T k T3/)14)(1()1(44)1()0(41-+=+=∑-=k k k i i k O O O T得：)4()(k O k T =由于覆盖一个kk 22⨯棋盘所需L 型骨牌个数为故算法是在渐进意义下最优的解//快速排序算法快速排序算法是对冒泡排序算法的一种改进，采用分治策略，步骤如下： 1. 选取一个基准元素（pivot ）2. 比pivot 小的放到pivot 左边，比pivot 大的放到pivot 右边3. 对pivot 左边的序列和右边的序列分别递归的执行步骤1和步骤2 平均情况下快速排序的时间复杂度是O (n\lgn )，最坏情况是O(n2)。

棋盘覆盖问题

分治法棋盘覆盖声明：本文使用的代码和例子的来源：《计算机算法设计与分析》（王晓东编著，电子工业出版社）。

我对代码做了少许修改，使可以在tc的图形模式下看到题目的结果。

题目：在一个(2^k)*(2^k)个方格组成的棋盘上，有一个特殊方格与其他方格不同，称为特殊方格，称这样的棋盘为一个特殊棋盘。

现在要求对棋盘的其余部分用L型方块填满（注：L 型方块由3个单元格组成。

即围棋中比较忌讳的愚形三角，方向随意），切任何两个L型方块不能重叠覆盖。

L型方块的形态如下：■■■■■■■，■ ，■■ ，■■题目的解法使用分治法，即子问题和整体问题具有相同的形式。

我们对棋盘做一个分割，切割一次后的棋盘如图1所示，我们可以看到棋盘被切成4个一样大小的子棋盘，特殊方块必定位于四个子棋盘中的一个。

假设如图1所示，特殊方格位于右上角，我们把一个L型方块（灰色填充）放到图中位置。

这样对于每个子棋盘又各有一个“特殊方块”，我们对每个子棋盘继续这样分割，知道子棋盘的大小为1为止。

用到的L型方块需要（4^k-1)/3 个，算法的时间是O（4^k)，是渐进最优解法。

本题目的C语言的完整代码如下（TC2.0下调试），运行时，先输入k的大小，(1<=k< =6)，然后分别输入特殊方格所在的位置(x,y), 0<=x,y<=(2^k-1)。

程序将绘制出覆盖后的棋盘，运行效果截图如图2所示。

[此程序在TC下课成功运行。

VC下缺少头文件<graphics.h>，编译时会出现错误。

]#include <stdio.h>#include <graphics.h>/*#include <cpyscr.h>*/#define N 64#define BoardLeft 2#define BoardTop 2int Board[N][N]; /*棋盘*/int tile;/*全局性质的L图形编号*/int CellSize=10;/*网格大小*/int BorderColor=LIGHTGRAY;/*用指定颜色填充一个单元格！*/void PutCell(int x,int y,int color){setfillstyle(SOLID_FILL,color);rectangle(BoardLeft+x*CellSize,BoardTop+y*CellSize,BoardLeft+(x+1) *CellSize,BoardTop+(y+1)*CellSize);floodfill(BoardLeft+x*CellSize+CellSize/2,BoardTop+y*CellSize+Cel lSize/2,BorderColor);}/*绘制L方块，（cx,cy）是L方块的中心点CELL坐标，pos从1到4，表示位于特殊方块位于哪个角（即缺失的一角位置）*/void PutBlock(int cx,int cy,int pos){int x,y,t=CellSize;/*方块起始点像素坐标*/x=BoardLeft+cx*CellSize;y=BoardTop+cy*CellSize;moveto(x,y);/*移动到中心点*/switch(pos){case 1:/*左上角缺*/lineto(x,y-t);lineto(x+t,y-t);lineto(x+t,y+t);lineto(x-t,y+t);lineto(x-t,y);break;case 2:/*右上角缺*/lineto(x+t,y);lineto(x+t,y+t);lineto(x-t,y+t);lineto(x-t,y-t);lineto(x,y-t);break;case 3:/*左下角缺*/lineto(x-t,y);lineto(x-t,y-t);lineto(x+t,y-t);lineto(x+t,y+t);lineto(x,y+t);break;case 4:/*右下角缺*/lineto(x,y+t);lineto(x-t,y+t);lineto(x-t,y-t);lineto(x+t,y-t);lineto(x+t,y);break;}lineto(x,y);/*回到闭合点！*/}/*初始化图形模式*/void InitGraph(){int gdriver=DETECT,gmode;initgraph(&gdriver,&gmode,"");setcolor(BorderColor);}/*关闭图形模式*/void CloseGraph(){closegraph();}/*打印棋盘*/void PrintBoard(int size){int i,j;clrscr();for(j=0;j<size;j++){for(i=0;i<size;i++){printf("%2d ",Board[i][j]);}printf("\n");}printf("\n--------------------------------\n");printf("size=%d;\n");}/*left,top：方块的左上角坐标，x,y：特殊方块的坐标 size:当前的子棋盘大小*/void ChessBoard(int left,int top,int x,int y,int size){int i,t,s,pos;/*t是方块的编号，s是棋盘的一半尺寸！(size/2),pos表示方块位于哪一角 */if(size==1)return;t=tile++;/*当前L行方块的编号！递增*/s=size/2;/*------------处理左上角----------*/if(x<left+s && y<top+s){ChessBoard(left,top,x,y,s);/*设置位于左上角的标识*/ pos=1;}else{Board[left+s-1][top+s-1]=t; /*不在左上角*/ ChessBoard(left,top,left+s-1,top+s-1,s);}/*------------处理右上角----------*/if(x>=left+s && y<top+s){ChessBoard(left+s,top,x,y,s);pos=2;}else{Board[left+s][top+s-1]=t;/*不在右上角*/ChessBoard(left+s,top,left+s,top+s-1,s);}/*------------处理左下角----------*/if(x<left+s && y>=top+s){ChessBoard(left,top+s,x,y,s);pos=3;}else{Board[left+s-1][top+s]=t;ChessBoard(left,top+s,left+s-1,top+s-1,s);}/*------------处理右下角----------*/if(x>=left+s && y>=top+s){ChessBoard(left+s,top+s,x,y,s);pos=4;}else{Board[left+s][top+s]=t;ChessBoard(left+s,top+s,left+s,top+s,s);}/*画出当前的L方块*/PutBlock(left+s,top+s,pos);}void main(){int size,k,x,y,i,j;printf("please input k=? (k should not more than 6, boardsize=2^k ): \n");scanf("%d",&k);size=1<<k;printf("please input position of the special cell. x=? (not more than %d): \n",size-1);scanf("%d",&x);printf("please input position of the special cell. y=? (not more than %d): \n",size-1);scanf("%d",&y);if(k<0 || k>6 || x<0 || x>(size-1) || y<0 || y>(size-1)){printf("Input invalid!\n");return;}InitGraph();tile=1;Board[x][y]=0;/*绘制特殊方块！*/PutCell(x,y,RED);ChessBoard(0,0,x,y,size);/*CopyScreen("c:\\tc\\temp\\chess.bmp",0,0,400,400);*/getch();CloseGraph();}2.#include"stdio.h"#include<graphics.h>#include<dos.h>#include<math.h>int tile=1;int avg;int basex,basey;void chessboard(int tr,int tc,int dr,int dc,int size)/*加了一个int tc*/{int s,t;if(size==1)return;t=tile++;s=size/2;delay(150000);setfillstyle(7,1);sound(500);delay(1500);sound(400);delay(1500);nosound();bar(dr*avg+basex,dc*avg+basey,(dr+1)*avg+basex,(dc+1)*avg+basey);if((dr*avg+basex)<tr+s*avg&&(dc*avg+basey)<tc+s*avg)chessboard(tr,tc,dr,dc,s);else{setfillstyle(1,t);bar(tr+(s-1)*avg,tc+(s-1)*avg,tr+s*avg,tc+s*avg);chessboard(tr,tc,(tr-basex)/avg+s-1,(tc-basey)/avg+s-1,s);}if((dr*avg+basex)<tr+s*avg&&(dc*avg+basey)>=tc+s*avg)chessboard(tr,tc+s*avg,dr,dc,s);else{setfillstyle(1,t);bar(tr+(s-1)*avg,tc+s*avg,tr+s*avg,tc+(s+1)*avg);/*在这加了一个tr+ s*avg*/chessboard(tr,tc+s*avg,(tr-basex)/avg+s-1,(tc-basey)/avg+s,s); }if((dr*avg+basex)>=tr+s*avg&&(dc*avg+basey)<tc+s*avg)chessboard(tr+s*avg,tc,dr,dc,s);else{setfillstyle(1,t);bar(tr+s*avg,tc+(s-1)*avg,tr+(s-1)*avg,tc+s*avg);chessboard(tr+s*avg,tc,(tr-basex)/avg+s,(tc-basey)/avg+s-1,s); }if((dr*avg+basex)>=tr+s*avg&&(dc*avg+basey)>=tc+s*avg)chessboard(tr+s*avg,tc+s*avg,dr,dc,s);else{setfillstyle(1,t);bar(tr+s*avg,tc+s*avg,tr+(s+1)*avg,tc+(s+1)*avg);chessboard(tr+s*avg,tc+s*avg,(tr-basex)/avg+s,(tc-basey)/avg+s,s);}}main(){int size,k;int dr,dc,tr,tc;int endx,endy;int i;double x,y;int gdriver=DETECT;int gmode=VGA;initgraph(&gdriver,&gmode,"");basex=300,basey=100;endx=basex+320;endy=basey+320;cleardevice();setcolor(12);settextstyle(2,0,8);outtextxy(20,20,"zhoumingjiang\n");/*改成了outtextxy函数~~*/ outtextxy(60,60,"designer:zhoumingjiang 25/10/2002");setbkcolor(BLACK);setcolor(RED);printf("\n\n\n");printf(" please input k: ");scanf("%d",&k);x=2;y=k;size=pow(x,y);avg=320/size;rectangle(basex,basey,endx,endy);for(i=0;i<=size;i++){setlinestyle(1,1,6);line(basex,basey+i*avg,endx,basey+i*avg);line(basex+i*avg,basey,basex+i*avg,endy);}printf(" please input dr,dc: ");scanf("%d,%d",&dc,&dr);tr=basex;tc=basey;chessboard(tr,tc,dr,dc,size);}3.棋盘覆盖(C语言)#include <stdio.h>#include <conio.h>#include <math.h>int title=1;int board[64][64];void chessBoard(int tr,int tc,int dr,int dc,int size) {int s,t;if(size==1) return;t=title++;s=size/2;if(dr<tr+s && dc<tc+s)chessBoard(tr,tc,dr,dc,s);else{board[tr+s-1][tc+s-1]=t;chessBoard(tr,tc,tr+s-1,tc+s-1,s); }if(dr<tr+s && dc>=tc+s)chessBoard(tr,tc+s,dr,dc,s);else{board[tr+s-1][tc+s]=t;chessBoard(tr,tc+s,tr+s-1,tc+s,s); }if(dr>=tr+s && dc<tc+s)chessBoard(tr+s,tc,dr,dc,s);else{board[tr+s][tc+s-1]=t;chessBoard(tr+s,tc,tr+s,tc+s-1,s); }if(dr>=tr+s && dc>=tc+s)chessBoard(tr+s,tc+s,dr,dc,s);else{board[tr+s][tc+s]=t;chessBoard(tr+s,tc+s,tr+s,tc+s,s);}}void main(){ int dr=0,dc=0,s=1,i=0,j=0;printf("print in the size of chess:\n"); scanf("%d",&s);printf("print in specal point x,y:\n"); scanf("%d%d",&dr,&dc);if(dr<s && dc<s){chessBoard(0,0,dr,dc,s);for(i=0;i<s;i++){for(j=0;j<s;j++){printf("%4d",board[i][j]);}printf("\n");}}elseprintf("the wrong specal point!!\n"); getch();}。

棋盘覆盖(算法实验代码)

实验一、棋盘覆盖代码及截图代码：#include <stdio.h>int tile=1;int Board[32][32];void ChessBoard(int tr,int tc,int dr,int dc,int size){if(size==1) return;int t=tile++;int s=size/2;if(dr<tr+s&&dc<tc+s)ChessBoard(tr,tc,dr,dc,s);else{Board[tr+s-1][tc+s-1]=t;ChessBoard(tr,tc,tr+s-1,tc+s-1,s);}if(dr<tr+s&&dc>=tc+s)ChessBoard(tr,tc+s,dr,dc,s);else{Board[tr+s-1][tc+s]=t;ChessBoard(tr,tc+s,tr+s-1,tc+s,s);}if(dr>=tr+s&&dc<tc+s)ChessBoard(tr+s,tc,dr,dc,s);else{Board[tr+s][tc+s-1]=t;ChessBoard(tr+s,tc,tr+s,tc+s-1,s);}if(dr>=tr+s&&dc>=tc+s)ChessBoard(tr+s,tc+s,dr,dc,s);else{Board[tr+s][tc+s]=t;ChessBoard(tr+s,tc+s,tr+s,tc+s,s);}}void main(){int size;printf("请输入棋盘的大小（大小为2的N次方）：");scanf("%d",&size);int x,y;printf("请输入特殊方格的坐标:");scanf("%d %d",&x,&y);ChessBoard(0,0,x,y,size);for(int i=0;i<size;i++){for(int j=0;j<size;j++)printf("%2d ",Board[i][j]);printf("\n");}}截图：。

算法棋盘覆盖

棋盘覆盖实现package Hell.hao;public class ChessBoard {/*int tr;int tc;//棋盘左上角方格的行列int dr;int dc;//分别是特殊方格的行和列*/int SIZE;int [][]board;int count=1;ChessBoard(){}ChessBoard(int size){SIZE=size;board=new int[SIZE][SIZE];}public void chessBoard(int tr,int tc,int dr,int dc,int size){if(size==1)return;int cover=count++;int s=size/2;if(dr<tr+s&&dc<tc+s){chessBoard(tr,tc,dr,dc,s);}//特殊方格在左上角else{board[tr+s-1][tc+s-1]=cover;//用L形覆盖其右下角chessBoard(tr,tc,tr+s-1,tc+s-1,s);}if(dr<tr+s&&dc>=tc+s){chessBoard(tr,tc+s,dr,dc,s);}//特殊方格在右上角else{board[tr+s-1][tc+s]=cover;chessBoard(tr,tc+s,tr+s-1,tc+s,s);}if(dr>=tr+s&&dc<tc+s){chessBoard(tr+s,tc,dr,dc,s);//tr+s 作为左下角}else{board[tr+s][tc+s-1]=cover;chessBoard(tr+s,tc,tr+s,tc+s-1,s);//左下角}if(dr>=tr+s&&dc>=tc+s){chessBoard(tr+s,tc+s,dr,dc,s);}else{board[tr+s][tc+s]=cover;//覆盖左上角chessBoard(tr+s,tc+s,tr+s,tc+s,s);//没有的话覆盖其他方格}}public void show(){for(int i=0;i<SIZE;i++){for(int j=0;j<SIZE;j++){if(j==0){System.out.print(board[i][j]);}else{System.out.printf("%4d",board[i][j]);}}System.out.println();System.out.println();}}}主函数：package Hell.hao;public class Application_01 {public static void main(String args[]){ ChessBoard cb =new ChessBoard(4);cb.board[2][2]=0;cb.chessBoard(0,0,2,2,4);cb.show();}}运行结果：。

分治算法实验 - 棋盘覆盖问题

实验步骤：
1、定义用于输入和输出的数据结构；
2、完成分治算法的编写；
3、测试记录结构；
4、有余力的同学尝试不改变输入输出结构，将递归消除，并说明能否不用栈，直接消除递归，为什么？
6、调试过程及实验结果
调试过程中有一点点的语法错误，如定义变量tile应定义为全局的整形变量，数组Board也是。另外输入的size应是，特殊方格的行标和列标都应小于size,如果输入的size不是的话，很显然结果不是我们要的。本程序的结果中我用-1表示特殊方格。
else{
Board[tr+s][tc+s-1]=t;
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
if(dr>=tr+s&&dc>=tc+s)
ChessBoard(tr+s,tc+s,dr,dc,s);
else{
Board[tr+s][tc+s]=t;
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
if(dr<tr+s&&dc>=tc+s)
ChessBoard(tr,tc+s,dr,dc,s);
else{
Board[tr+s-1][tc+s]=t;
ChessBoard(tr,tc+s,tr+s-1,tc+s-1,s);
}
if(dr>=tr+s&&dc<tc+s)
ChessBoard(tr+s,tc,dr,dc,s);

分治法棋盘覆盖

算法分析与设计实验报告—分治法解决棋盘覆盖问题一、实验目的建立算法复杂度的理论分析与实验分析的联系，深刻体会算法复杂度作为算法的好坏评价指标的本质含义。

二、实验要求1、用c++程序语言实现分治法解决棋盘覆盖问题。

2、分析算法的时间复杂度三、实验原理用分治策略，可以设计解决棋盘问题的一个简介算法。

当k>0时，可以将2^k *2^k棋盘分割为4个2^k-1 * 2^k-1子棋盘。

由棋盘覆盖问题得知，特殊方格必位于4个较小的子棋盘中，其余3个子棋盘中无特殊方格。

为了将3个无特殊方格的子棋盘转化为特殊棋盘可以将一个L型骨牌覆盖这3个较小棋盘的会合处，所以，这3个子棋盘上被L型覆盖的方格就成为给棋盘上的特殊方格，从而将原问题转化为4个较小规模的棋盘覆盖问题。

递归的使用这种分割，直至棋盘简化为1*1棋盘为止。

四、实验过程(步骤)1、数据说明：tr：棋盘上左上角方格的行号tc：棋盘上左上角方格的列号dr：特殊方格所在的行号dc：特殊方格所在的列号定义了全局变量tile，用于进行覆盖。

区分4种不同L类型的骨牌，初始值为0.Board[]数组用来表示棋盘2、函数说明ChessBoard函数实现了递归的将棋盘划分为子棋盘，并将棋盘进行覆盖。

main()函数用来进行输入棋盘的大小和特殊棋盘的位置。

使用memset(Board,0,sizeof(Board))将Board[]数组清零使用setw()函数控制输出格式五、运行结果六、实验分析与讨论设T（n）是算法ChessBoard覆盖一个2^k * 2^k棋盘所需要的时间，则从算法的分治策略可知，T(k)满足如下递归方程：O（1）k = 0T(k) = {4T(k-1)+O（1）k>0解得此递归方程可得T(k) = O（4^k）。

由于覆盖一个2^k *2^k棋盘所需的L型骨牌个数为（4^k —1）/3,故算法ChessBoard是一个在渐进意义下最优的算法七、实验心得通过这次试验，更多的了解了分治法解题的思路就是将大问题化为若干子问题，再依次解决子问题，最后获得问题的答案。