分治算法实验 - 棋盘覆盖问题
算法分析与设计教案
算法分析与设计课程教案课程编号：50c24037-01总学时：51 周学时：4适用年级专业（学科类）：2007级计科专业开课时间：2010－2011 学年第1 学期使用教材：王晓东编著计算机算法设计与分析第3版章节第1章1.1~ 1.2 第2 章2.1 课时 2教学目的理解程序与算法的概念、区别与联系；掌握算法在最坏情况、最好情况和平均情况下的计算复杂性概念；掌握算法复杂性的渐近性态的数学表述；理解递归的概念。
教学重点及突出方法重点：程序与算法的概念、算法的时间复杂性、算法复杂性的渐近性态的数学表述以及递归的概念。
通过讲解、举例方法。
教学难点及突破方法难点：算法复杂性与递归通过讲解、举例、提问与引导方法。
相关内容此部分内容基础知识可参考清华大学出版社出版严蔚敏编著的《数据结构》教学过程（教师授课思路、设问及讲解要点）回顾数据结构课程中的算法概念、排序算法等知识，从而引出本课程内容。
提问算法与程序的区别、联系以及算法具有的特性。
讲解算法的复杂性，主要包括时间复杂性与空间复杂性。
讲解最坏情况、最好情况与平均情况的时间复杂性。
讲解算法复杂性在渐近意义下的阶，主要包括O、Ω、θ与o，并通过具体例子说明。
通过具体例子说明递归技术。
主要包括阶乘函数、Fibonacci数列、Ackerman函数、排列问题、整数划分问题、Hanoi塔问题等。
第页章节第2 章2.2~2.5 课时 2 教学目的掌握设计有效算法的分治策略，并掌握范例的设计技巧，掌握计算算法复杂性方法。
教学重点及突出方法重点：分治法的基本思想及分治法的一般设计模式。
通过讲解、举例方法。
教学难点及突破方法难点：计算算法复杂性。
通过讲解、举例、提问与引导方法。
相关内容素材教（教师授课思路、设问及讲解要点）学过程通过生活中解决复杂问题的分解方法，引出分治方法。
讲解分治法的基本思想及其一般算法的设计模式，介绍分治法的计算效率。
通过具体例子采用分治思想来设计有效算法。
分治算法-残缺棋盘
分治算法-残缺棋盘残缺棋盘是⼀个2^k*2^个⽅格的棋盘，其中恰有1个⽅格残缺。
图中给出，其中残缺部分⽤阴影表⽰。
这样的棋盘称为"三格板"，残缺棋盘问题就是⽤这四种三格板覆盖更⼤的残缺棋盘。
再次覆盖中要求:(1)两个三格板不能重复。
(2)三格板不能覆盖残缺棋盘⽅格，但必须覆盖到其他所有的⽅格。
算法思路:利⽤分治算法将棋盘细化，逐步解决,以4*4为例⾸先判断残缺的位置在哪⾥，然后在中间填上对应的三格板，如在上图中间拼上三⾓板(4)，变成下⾯这样然后通过中间将其分成了4个2*2的⼩残缺棋盘，从⽽问题得以解决4*4的分析过于简单，现在我们以8*8为例进⾏分析，能更清楚的理解这个例⼦中分治算法的思想⾸先将三格板放置在中间，将其分4个⼩的4*4的残缺棋盘通过红⾊线将其划分成4个4*4的残缺棋盘，现在以左上的残缺棋盘为例然后将左的4*4的⼩棋盘右划分成了4个2*2的⼩棋盘，这样就将问题优化成了2*2的三⾓棋盘的⼩问题，这样很快就能将左上的4*4的残缺棋盘解决了下⾯继续分析右上的4*4的棋盘，根据残缺的⽅格在⼩棋盘中的位置，在中间选择合适的三格板将⼩的残缺棋盘继续划分，将问题分化成更⼩的状态接着的问题和上⾯⼀样分析。
右上⾓的⼩棋盘很快也能解决了，下⾯两块残缺棋盘的分析⽅法和上⾯的⼀样，整个问题就这样⼀步步的分解成⼩问题，然后解决了。
下⾯是源代码#include <iostream>using namespace std;int amount,Board[100][100];void Cover(int tr,int tc,int dr,int dc,int size){int s,t;if(size<2)return ;amount++;t=amount;s=size/2;if(dr<tr+s&&dc<tc+s)//残缺在左上⾓{//覆盖中间位置Board[tr+s-1][tc+s]=t;Board[tr+s][tc+s-1]=t;Board[tr+s][tc+s]=t;Cover(tr,tc,dr,dc,s);//覆盖左上Cover(tr,tc+s,tr+s-1,tc+s,s);//覆盖右上Cover(tr+s,tc,tr+s,tc+s-1,s);//覆盖左下Cover(tr+s,tc+s,tr+s,tc+s,s);//覆盖右下}else if(dr<tr+s&&dc>=tc+s)//残缺在右上⾓{Board[tr+s-1][tc+s-1]=t;Board[tr+s][tc+s-1]=t;Board[tr+s][tc+s]=t;Cover(tr,tc,tr+s-1,tc+s-1,s);Cover(tr,tc+s,dr,dc,s);Cover(tr+s,tc,tr+s,tc+s-1,s);Cover(tr+s,tc+s,tr+s,tc+s,s);}else if(dr>=tr+s&&dc<tc+s)//残缺在左下 {Board[tr+s-1][tc+s-1]=t;Board[tr+s-1][tc+s]=t;Board[tr+s][tc+s]=t;Cover(tr,tc,tr+s-1,tc+s-1,s);Cover(tr,tc+s,tr+s-1,tc+s,s);Cover(tr+s,tc,dr,dc,s);Cover(tr+s,tc+s,tr+s,tc+s,s);}else{Board[tr+s-1][tc+s-1]=t;Board[tr+s-1][tc+s]=t;Board[tr+s][tc+s-1]=t;Cover(tr,tc,tr+s-1,tc+s-1,s);Cover(tr,tc+s,tr+s-1,tc+s,s);Cover(tr+s,tc,tr+s,tc+s-1,s);Cover(tr+s,tc+s,dr,dc,s);}}void Print(int s){for(int i=1;i<=s;i++){for(int j=1;j<=s;j++)printf("%5d ",Board[i][j]);printf("\n");}}int main(){int s=1,k,x,y;printf("输⼊2残缺棋盘的规模:2^k,k="); scanf("%d",&k);for(int i=1;i<=k;i++)s*=2;printf("输⼊棋盘残缺位置(x,y):");scanf("%d%d",&x,&y);Board[x][y]=0;Cover(1,1,x,y,s);Print(s);return 0;}。
棋盘覆盖问题c语言
// 覆盖本子棋盘中的其余方格
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
}
//覆盖右上角子棋盘
if(dr<tr+s&&dc>=tc+s)
// 特殊方格在此棋盘中
ChessBoard(tr,tc,dr,dc,s);
else
{//特此棋盘中无特殊方格 ,t号L型骨牌覆盖左下角
{//此棋盘中无特殊方格 ,t号L型骨牌覆盖左上角
board[tr+s][tc+s]=t;
// 覆盖本子棋盘中的其余方格
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}
int main()
{
int size,r,c,row,col;
printf("输入棋盘大小：\n");
scanf("%d",&size);//输入棋盘大小
{
for (c = 0; c < size; c++)
{
printf("%d ",board[r][c]);
}
printf("\n");
}
return 0;
}
运行效果：
实验报告成绩
老师
注：1）专业班级按打印课表中名称填写；2）课程名称按课表中名称填写，不能简写；
3）实验日期格式示例：）实验时间格式示例：“第三大节”5）实验情况包括任务（或题目）、解决方案（或者代码）、结果等；6）实验报告成绩按五级标准评分；精心搜集整理，只为你的需要
算法设计与分析实验报告棋盘覆盖问题
算法设计与分析实验报告棋盘覆盖问题贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告课程名称:算法设计与分析班级:信计101班实验日期:2013-9-30 姓名: 张胜学号:1007010162 指导教师:程欣宇实验序号:一实验成绩: 一、实验名称分治算法实验 - 棋盘覆盖问题二、实验目的及要求1、熟悉递归算法编写;2、理解分治算法的特点;3、掌握分治算法的基本结构。
三、实验环境Visual C++四、实验内容根据教材上分析的棋盘覆盖问题的求解思路，进行验证性实验;要求完成棋盘覆盖问题的输入、分治求解、输出。
有余力的同学尝试消去递归求解。
五、算法描述及实验步骤分治算法原理:分治算法将大的分解成形状结构相同的子问题，并且不断递归地分解，直到子问题规模小到可以直接求解。
棋盘覆盖问题描述:在一个2k x 2k个方格组成的棋盘中恰有一个方格与其他的不同称为特殊方格，想要求利用四种L型骨牌(每个骨牌可覆盖三个方格)不相互重叠覆盖的将除了特殊方格外的其他方格覆盖。
实验步骤:1、定义用于输入和输出的数据结构;2、完成分治算法的编写;3、测试记录结构;4、有余力的同学尝试不改变输入输出结构，将递归消除，并说明能否不用栈，直接消除递归，为什么,六、调试过程及实验结果实验运行结果:七、总结通过本次实验，我更深的理解了递归和分治策略。
代码是书上的算法，加上主函数就行了，用的是C语言编写，很长时间没用了，感觉有点生疏。
实验结果有点问题，就是覆盖棋盘时，并不是按照1，2，3….的字符顺序，而是按照很乱的顺序输出字符，这个我不知道怎么解决，就没解决。
八、附录#include "stdio.h"#include "conio.h"int board[8][8] ={{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0 ,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0}};int tile=0;void chessBoard(int tr, int tc, int dr, intdc, int size){int t=tile++,s=size/2;if (size==1) return;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);} }main(){int i ,j;chessBoard(0,0,5,5,8);for(i=0;i <8;i++){for( j=0;j <8;j++) {if(board[i][j]<10)printf("0");printf("%d",board[i][j]);printf(" ");}printf( "\n"); } getchar();}。
计算机算法设计五大常用算法的分析及实例
计算机算法设计五⼤常⽤算法的分析及实例摘要算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
也就是说，能够对⼀定规范的输⼊，在有限时间内获得所要求的输出。
如果⼀个算法有缺陷，或不适合于某个问题，执⾏这个算法将不会解决这个问题。
不同的算法可能⽤不同的时间、空间或效率来完成同样的任务。
其中最常见的五中基本算法是递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法。
本⽂通过这种算法的分析以及实例的讲解，让读者对算法有更深刻的认识，同时对这五种算法有更清楚认识关键词：算法，递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法AbstractAlgorithm is the description to the problem solving scheme ,a set of clear instructions to solve the problem and represents the describe the strategy to solve the problem using the method of system mechanism . That is to say, given some confirm import，the Algorithm will find result In a limited time。
If an algorithm is defective or is not suitable for a certain job, it is invalid to execute it. Different algorithms have different need of time or space, and it's efficiency are different.There are most common algorithms: the recursive and divide and conquer、dynamic programming method、greedy algorithm、backtracking、branch and bound method.According to analyze the five algorithms and explain examples, make readers know more about algorithm , and understand the five algorithms more deeply.Keywords: Algorithm, the recursive and divide and conquer, dynamic programming method, greedy algorithm、backtracking, branch and bound method⽬录1. 前⾔ (4)1.1 论⽂背景 (4)2. 算法详解 (5)2.1 算法与程序 (5)2.2 表达算法的抽象机制 (5)2.3 算法复杂性分析 (5)3．五中常⽤算法的详解及实例 (6)3.1 递归与分治策略 (6)3.1.1 递归与分治策略基本思想 (6)3.1.2 实例——棋盘覆盖 (7)3.2 动态规划 (8)3.2.1 动态规划基本思想 (8)3.2.2 动态规划算法的基本步骤 (9)3.2.3 实例——矩阵连乘 (9)3.3 贪⼼算法 (11)3.3.1 贪⼼算法基本思想 (11)3.3.2 贪⼼算法和动态规划的区别 (12)3.3.3 ⽤贪⼼算法解背包问题的基本步骤： (12)3.4 回溯发 (13)3.4.1 回溯法基本思想 (13)3.3.2 回溯发解题基本步骤 (13)3.3.3 实例——0-1背包问题 (14)3.5 分⽀限界法 (15)3.5.1 分⽀限界法思想 (15)3.5.2 实例——装载问题 (16)总结 (18)参考⽂献 (18)1. 前⾔1.1 论⽂背景算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
棋盘覆盖问题算法思路
棋盘覆盖问题算法思路
棋盘覆盖问题是一道经典的分治算法问题，通常用于介绍分治算法的思想。
其基本思路是将棋盘分成若干个小块，然后在其中一个小块上放置一块特殊的骨牌，然后将剩下的小块按照同样的方式继续分成更小的块，并在其中一个小块上放置另一块骨牌，以此类推，直到整个棋盘被覆盖。
具体的实现过程可以采用递归的方式，将棋盘不断地分成四个部分，然后在其中一个部分上放置一块骨牌，再递归求解另外三个部分。
在实现过程中，需要注意处理边界条件和特殊情况，例如棋盘大小为1x1或者存在特殊方块无法覆盖等情况。
该算法的时间复杂度为O(2^n)，其中n为棋盘大小的指数。
虽然时间复杂度较高，但是由于该问题特殊的递归性质使得其能够被高效地并行化，因此在实际应用中仍有广泛的应用。
OpenJudge算法设计与分析习题解答
1、硬币面值组合描述使用1角、2角、5角硬币组成n 角钱。
设1角、2角、5角的硬币各用了a、b、c个，列出所有可能的a, b, c组合。
输出顺序为：先按c的值从小到大，若c相同则按b的值从小到大。
输入一个整数n（1 <= n <= 100)，代表需要组成的钱的角数。
输出输出有若干行，每行的形式为：i a b c第1列i代表当前行数（行数从001开始，固定3个字符宽度，宽度不足3的用0填充），后面3列a, b, c分别代表1角、2角、5角硬币的个数（每个数字固定12个字符宽度，宽度不足的在左边填充空格）。
样例输入样例输出源代码：#include<stdio.h>#include<stdlib.h>int main(){int t=1;int i,j,k;int n;scanf("%d",&n);int A=n,B=n/2,C=n/5;for(i=0;i<=C;i++){for(j=0;j<=B;j++){for(k=0;k<=A;k++){if(i*5+j*2+k*1==n){printf("%03d%12d%12d%12d\n",t,k,j,i);t++;}}}}getchar();return 0;}2、比赛排名描述5名运动员参加100米赛跑，各自对比赛结果进行了预测：A说：E是第1名。
B说：我是第2名。
C说：A肯定垫底。
D说：C肯定拿不了第1名。
E说：D应该是第1名。
比赛结束后发现，只有获第1名和第2名的选手猜对了，E不是第2名和第3名，没有出现名次并列的情况。
请编程判断5位选手各是第几名。
输入无输出输出要求：按ABCDE的顺序输出5行，其中第1行是A的名次，第2行是B的名次，第3行是C的名次，第4行是D的名次，第5行是E的名次。
样例输入样例输出源代码：#include<stdio.h>int main(){printf("5\n");printf("2\n");printf("1\n");printf("3\n");printf("4\n");return 0;}3、鸡兔同笼描述一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。
棋盘上的数学问题
希望杯
希望杯
学数
数学
竞 赛 题 竞 赛 题
(a)
(b)
图4
(要求 :每次移动网格中的字块时 ,只能
将字块滑动到相邻的空的网格中. )
(第 16 届“希望杯”全国数学邀请赛)
解 :将“希 、望 、杯 、数 、学 、竞 、赛 、题”八个
字分别记为 1 、2 、3 、4 、5 、6 、7 、8 ,则图 4 (a) 变为
③
a4 + a5 + a6 = 15.
④
①+ ②+ ③+ ④得
3 a5 + ( a1 + a2 + …+ a9 ) = 60 ,
即 3 a5 + 45 = 60 ,得 a5 = 5.
余下的 8 个数中有 4 个偶数 、4 个奇数.
若假设 a1 为奇数 ,则由式 ①知 a9 必为奇数.
分类讨论如下 :
14
综上 ,如图 8 所填的 3 ×3 棋盘 , 使 M 有最大 值 ,且最大值为 58.
注 :填数方法不唯一.
4 棋盘的覆盖问题
817 492 536
图8
这 里 的 覆 盖 问 题 是 指 最 简 单 的 一 类 覆
盖 ,即棋盘的完全覆盖 (在棋盘的覆盖中 ,各
个覆盖形的总格数等于棋盘的总格数) . 完全
在 3 ×3 网格的同一行中 ,按照要求调整 时 ,对应数字只能左右移动 ,移动前后的棋盘 所对应的八位数完全相同 ,相应的逆序的总 数不发生变化.
如果按照要求 ,将数字移动到相邻的行 中 ,相当于在对应的八位数中 ,将某个数字向 左 (或向右) 跳过了两个数字. 注意到在一个 多位数中 ,两个相邻数字交换位置 ,逆序总数 的变化量只能是 1 或 - 1 ,于是 ,将数字移动 到相邻的行时 ,对应的八位数的逆序总数的 变化量只能是 2 或 0 或 - 2.
棋盘覆盖(分治法)
}
/*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);
算法与设计实验报告
实验一分治与递归（4学时）一、实验目的与要求1、熟悉C/C++语言的集成开发环境；2、通过本实验加深对递归过程的理解二、实验内容掌握递归算法的概念和基本思想，分析并掌握“整数划分”问题的递归算法。
三、实验题任意输入一个整数，输出结果能够用递归方法实现整数的划分。
四、程序代码五、实验结果首先按照提示输入数字：按回车键，得到此数划分的个数：此时您可以接着计算另一个数的划分个数：若要退出，请输入一个小于等于零的数：六、结果分析及程序功能经过和其它同学的实验数据对比，初步认定此程序基本正确，然而不足之处是只能得到划分的个数，而不能列出每个划分的详细情况。
一、实验目的与要求1、掌握棋盘覆盖问题的算法；2、初步掌握分治算法二、实验题盘覆盖问题：在一个2k×2k个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。
在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
三、程序代码四、实验结果按照提示输入特殊方格的行号和列号（起始行列号为0）：按回车键，得到一个矩阵，数字相同区域为一个L型骨牌覆盖：五、结果分析及程序功能得到的16*16棋盘覆盖结果正确，此程序的不足之处：只能设定特殊方格的行列号，而不能设定棋盘的大小。
实验二动态规划算法(4学时)一、实验目的与要求1、熟悉最长公共子序列问题的算法；2、初步掌握动态规划算法；二、实验题若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。
例如，序列Z={B，C，D，B}是序列X={A，B，C，B，D，A，B}的子序列，相应的递增下标序列为{2，3，5，7}。
给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
五、算法描述及实验步骤
分治算法原理：
分治算将大的分解成形状结构相同的子问题，并且不断递归地分解，直到子问题规模小到可以直接求解。
棋盘覆盖问题描述：
在一个2k x 2k个方格组成的棋盘中恰有一个方格与其他的不同称为特殊方格，想要求利用四种L型骨牌（每个骨牌可覆盖三个方格）不相互重叠覆盖的将除了特殊方格外的其他方格覆盖。
voidChessBoard(inttr,inttc,intdr,intdc,intsize);
void main()
{
intsize,dr,dc,i,j;
printf("inputsize,dr,dc:\n");//输入
scanf("%d,%d,%d",&size,&dr,&dc);
Board[dr][dc]=-1;
{
if(size==1)return;
intt=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);
}
ChessBoard(0,0,dr,dc,size);
printf("output:\n");//输出
for(i=0;i<size;i++){
for(j=0;j<size;j++)
printf("%d ",Board[i][j]);
printf("\n");
}
}
//实现算法
voidChessBoard(inttr,inttc,intdr,intdc,intsize)
实验步骤：
1、定义用于输入和输出的数据结构；
2、完成分治算法的编写；
3、测试记录结构；
4、有余力的同学尝试不改变输入输出结构，将递归消除，并说明能否不用栈，直接消除递归，为什么？
6、调试过程及实验结果
调试过程中有一点点的语法错误，如定义变量tile应定义为全局的整形变量，数组Board也是。另外输入的size应是 ，特殊方格的行标和列标都应小于size,如果输入的size不是 的话，很显然结果不是我们要的。本程序的结果中我用-1表示特殊方格。
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);
实验结果为：
七、总结
此次实验的算法已经从书本上得到，代码是网上找的。但是我已经读懂了。棋盘覆盖的分治策略算法也简单易懂，是我们学习分治策略的思想的典型例子。
棋盘覆盖的分治策略算法利用四种L型骨牌，代码有解释。
八、附录
#include<stdio.h>
inttile=0;
intBoard[100][100];
课程名称：算法设计与分析
班级：
实验日期：
姓名：
学号：
指导教师：
实验序号：一
实验成绩：
一、实验名称
分治算法实验-棋盘覆盖问题
二、实验目的及要求
1、熟悉递归算法编写；
2、理解分治算法的特点；
3、掌握分治算法的基本结构。
三、实验环境
Visual C++
四、实验内容
根据教材上分析的棋盘覆盖问题的求解思路，进行验证性实验；
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);
}
}