棋盘覆盖算法C#
计算机算法设计和分析习题及答案解析
计算机算法设计和分析习题及答案解析This manuscript was revised on November 28, 2020《计算机算法设计与分析》习题及答案一．选择题1、二分搜索算法是利用（ A ）实现的算法。
A、分治策略B、动态规划法C、贪心法D、回溯法2、下列不是动态规划算法基本步骤的是（ A ）。
A、找出最优解的性质B、构造最优解C、算出最优解D、定义最优解3、最大效益优先是（A ）的一搜索方式。
A、分支界限法B、动态规划法C、贪心法D、回溯法4. 回溯法解旅行售货员问题时的解空间树是（ A ）。
A、子集树B、排列树C、深度优先生成树D、广度优先生成树5．下列算法中通常以自底向上的方式求解最优解的是（B ）。
A、备忘录法B、动态规划法C、贪心法D、回溯法6、衡量一个算法好坏的标准是（ C ）。
A 运行速度快B 占用空间少C 时间复杂度低D 代码短7、以下不可以使用分治法求解的是（ D ）。
A 棋盘覆盖问题B 选择问题C 归并排序D 0/1背包问题8. 实现循环赛日程表利用的算法是（A ）。
A、分治策略B、动态规划法C、贪心法D、回溯法9．下面不是分支界限法搜索方式的是（D ）。
A、广度优先B、最小耗费优先C、最大效益优先D、深度优先10．下列算法中通常以深度优先方式系统搜索问题解的是（D ）。
A、备忘录法B、动态规划法C、贪心法D、回溯法11.备忘录方法是那种算法的变形。
（ B ）A、分治法B、动态规划法C、贪心法D、回溯法12．哈夫曼编码的贪心算法所需的计算时间为（B ）。
A、O（n2n）B、O（nlogn）C、O（2n）D、O（n）13．分支限界法解最大团问题时，活结点表的组织形式是（B ）。
A、最小堆B、最大堆C、栈D、数组14．最长公共子序列算法利用的算法是（B）。
A、分支界限法B、动态规划法C、贪心法D、回溯法15．实现棋盘覆盖算法利用的算法是（A ）。
A、分治法B、动态规划法C、贪心法D、回溯法16.下面是贪心算法的基本要素的是（C ）。
算法分析与设计(山东联盟)智慧树知到答案章节测试2023年泰山学院
绪论单元测试1.山东师范大学的管教授在哪个问题上给出了比较好的解决方法。
A:邮递员问题B:背包问题C:装载问题D:最大团问题答案:A第一章测试1.算法具备的四个基本性质是（）A:输入B:有限性C:确定性D:输出答案:ABCD2.算法就是程序A:错B:对答案:A3.描述渐进上界的符号是（）A:ΩB:ωC:OD:θ答案:C4.f(n)=3n2+n+1,下面不正确的是()A:f(n)=O(n3)B:f(n)=O(n2)C:f(n)=O(2n)D:f(n)=O(3n2)答案:C5.在算法分析中，我们希望找到更加高阶的上界函数A:错B:对答案:A第二章测试1.Strassen 矩阵乘法是利用（）实现的算法。
A:贪心法B:分治策略C:动态规划法D:回溯法答案:B2.使用分治法求解不需要满足的条件是（）A:子问题不能够重复B:子问题的解可以合并C:子问题必须是一样的D:原问题和子问题使用相同的方法解答案:C3.实现棋盘覆盖算法利用的算法是（）。
A:分治法B:回溯法C:动态规划法D:贪心法答案:A4.实现循环赛日程表利用的算法是（）。
A:贪心法B:回溯法C:分治策略D:动态规划法答案:C5.从分治法的一般设计模式可以看出，用它设计出的程序一般是递归算法A:对B:错答案:A第三章测试1.动态规划算法一般分成（）三个阶段。
A:求解B:分析C:分段D:汇总答案:ABC2.动态规划的基本要素有（）？A:备忘录方法B:最优子结构C:子问题的重叠性质答案:ABC3.用动态规划法求解的问题都可以分解为相互重叠的子问题。
A:对B:错答案:A4.动态规划法利用递推关系式（）计算，实现动态规划过程。
A:循环B:递归C:自底向上D:自顶向下答案:C5.最优子结构是问题可以用动态规划法求解的前提。
A:错B:对答案:B第四章测试1.贪心算法中每次做出的贪心选择都是全局最优选择。
A:对B:错答案:B2.下面问题不能使用贪心法解决的是A:N皇后问题B:最小花费生成树问题C:背包问题D:单源最短路径问题答案:A3.背包问题的贪心算法所需的计算时间为A:O（n2n）B:O（n）C:O（nlogn）D:O（2n）答案:C4.哈夫曼编码是自底向上构造的A:错B:对答案:B5.Kruskal算法的时间复杂度是A:O（eloge）B:O（n）C:O（nlogn）D:O（2n）答案:A第五章测试1.回溯法就是穷举法A:错B:对答案:A2.回溯法使用的是广度优先遍历A:对B:错答案:B3.回溯法必须寻找一个限界函数A:对B:错答案:B4.使用回溯法时可以考虑以下哪些方面()A:约束函数B:解空间结构C:解的向量形式D:解的最优子结构性质答案:ABC5.回溯法在处理n皇后问题时，必须把解空间组织成子集树。
棋盘覆盖问题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）实验报告成绩按五级标准评分；精心搜集整理，只为你的需要
残缺棋盘问题
残缺棋盘问题的VC++实现1.问题分析残缺棋盘（defective chessboard）是一个有2k×2k个方格的棋盘，其中恰有一个方格残缺。
图1给出k≤2时各种可能的残缺棋盘，其中残缺的方格用阴影表示。
注意当k=0时，仅存在一种可能的残缺棋盘（如图1a所示）。
事实上，对于任意k，恰好存在22k种不同的残缺棋盘。
残缺棋盘的问题是：要求用三格板（triominoes）覆盖残缺棋盘（如图2所示）。
在此覆盖中，两个三格板不能重叠，三格板不能覆盖残缺方格，但必须覆盖其他所有的方格。
在这种限制条件下，所需要的三格板总数为(22k-1)/3。
可以验证(22k-1)/3是一个整数。
k为0的残缺棋盘很容易被覆盖，因为它没有非残缺的方格，用于覆盖的三格板的数目为0。
当k=1时，正好存在3个非残缺的方格，并且这三个方格可用图2中的某一方向的三格板来覆盖。
用分而治之方法可以很好地解决残缺棋盘问题。
这一方法可将覆盖2k×2k残缺棋盘的问题转化为覆盖较小残缺棋盘的问题。
2k×2k棋盘一个很自然的划分方法就是将它划分为如图3a所示的4个2k-1×2k-1棋盘。
注意到当完成这种划分后，4个小棋盘中仅仅有一个棋盘存在残缺方格。
首先覆盖其中包含残缺方格的2k-1×2k-1残缺棋盘，然后把剩下的3个小棋盘转变为残缺棋盘，为此将一个三格板放在由这3个小棋盘形成的角上，如图3b所示，其中原2k×2k棋盘中的残缺方格落入左上角的2k-1×2k-1棋盘。
可以采用这种分割技术递归地覆盖2k×2k残缺棋盘。
当棋盘的大小减为1×1时，递归过程终止。
此时1×1的棋盘中仅仅包含一个方格且此方格残缺，所以无需放置三格板。
图1图2图32.算法选择用分而治之方法解决此问题，即为了解决一个大的问题，可以：1)把它分成两个或多个更小的问题；2)分别解决每个小问题；3)把各小问题的解答组合起来，即可得到原问题的解答。
算法分析与设计试题
一、选择题（20分）1．最长公共子序列算法利用的算法是（B ）。
A、分支界限法B、动态规划法C、贪心法D、回溯法2．实现棋盘覆盖算法利用的算法是（A ）。
A、分治法B、动态规划法C、贪心法D、回溯法3.下面是贪心算法的基本要素的是（C ）。
A、重叠子问题B、构造最优解C、贪心选择性质D、定义最优解4.回溯法的效率不依赖于下列哪些因素（ D ）A.满足显约束的值的个数B. 计算约束函数的时间C. 计算限界函数的时间D. 确定解空间的时间5.下面哪种函数是回溯法中为避免无效搜索采取的策略（B ）A．递归函数 B.剪枝函数C。
随机数函数 D.搜索函数6．采用最大效益优先搜索方式的算法是（A ）。
A、分支界限法B、动态规划法C、贪心法D、回溯法7．贪心算法与动态规划算法的主要区别是（B ）。
A、最优子结构B、贪心选择性质C、构造最优解D、定义最优解8. 实现最大子段和利用的算法是（B ）。
A、分治策略B、动态规划法C、贪心法D、回溯法9.优先队列式分支限界法选取扩展结点的原则是（C ）。
A、先进先出B、后进先出C、结点的优先级D、随机10.下列算法中通常以广度优先方式系统搜索问题解的是（A）。
A、分支限界法B、动态规划法C、贪心法D、回溯法二、填空题（22分每空2分）1.算法是由若干条指令组成的有穷序列，且要满足输入、输出、确定性和有限性四条性质。
2、大整数乘积算法是用分治法来设计的。
3、以广度优先或以最小耗费方式搜索问题解的算法称为分支限界法。
4、舍伍德算法总能求得问题的一个解。
5、贪心选择性质是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
6.快速排序template<class Type>void QuickSort (Type a[], int p, int r){if (p<r) {int q=Partition(a,p,r);QuickSort (a,p,q-1); 哈密顿环问题的算法可由回溯法设计实现。
计算机算法与设计复习题(含答案) (1)
一、选择题1、衡量一个算法好坏的标准是（C ）。
（A）运行速度快（B）占用空间少（C）时间复杂度低（D）代码短2、记号O的定义正确的是（A）。
（A）O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n≥n0有：0≤f(n) ≤cg(n) }；（B）O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n≥n0有：0≤cg(n) ≤f(n) }；（C）O(g(n)) = { f(n) | 对于任何正常数c>0，存在正数和n0 >0使得对所有n≥n0 有：0 ≤f(n)<cg(n) }；（D）O(g(n)) = { f(n) | 对于任何正常数c>0，存在正数和n0 >0使得对所有n≥n0 有：0 ≤cg(n) < f(n) }；3、二分搜索算法是利用（ A ）实现的算法。
（A）分治策略（B）动态规划法（C）贪心法（D）回溯法4、使用分治法求解不需要满足的条件是（A ）。
（A）子问题必须是一样的（B）子问题不能够重复（C）子问题的解可以合并（D）原问题和子问题使用相同的方法解5、合并排序算法是利用（A）实现的算法。
（A）分治策略（B）动态规划法（C）贪心法（D）回溯法6、实现大整数的乘法是利用（C ）的算法。
（A）贪心法（B）动态规划法（C）分治策略（D）回溯法7、以下不可以使用分治法求解的是（D ）。
（A）棋盘覆盖问题（B）选择问题（C）归并排序（D）0/1背包问题8、实现循环赛日程表利用的算法是（ A ）。
（A）分治策略（B）动态规划法（C）贪心法（D）回溯法9、实现棋盘覆盖算法利用的算法是（ A ）。
（A）分治法（B）动态规划法（C）贪心法（D）回溯法10、矩阵连乘问题的算法可由（B）设计实现。
（A）分支界限算法（B）动态规划算法（C）贪心算法（D）回溯算法11、实现大整数的乘法是利用的算法（ C ）。
（A）贪心法（B）动态规划法（C）分治策略（D）回溯法12、最长公共子序列算法利用的算法是（B）（A）分支界限法（B）动态规划法（C ）贪心法（D）回溯法13、下列算法中通常以自底向上的方式求解最优解的是（B ）（A）备忘录法（B）动态规划法（C）贪心法（D）回溯法14、下列是动态规划算法基本要素的是（D）（A）定义最优解（B）构造最优解（C）算出最优解（D）子问题重叠性质15、下列不是动态规划算法基本步骤的是（ A ）。
棋盘覆盖算法
棋盘覆盖算法棋盘覆盖算法（Tiling Puzzle）是用小的拼图块填满一个大的棋盘的问题，这些拼图块称作多米诺骨牌，每一块都覆盖两个格子，而棋盘的大小为2的n次方×2的n次方，其中n是整数。
在一个棋盘和一组多米诺骨牌下，棋盘恰好可以被所有的多米诺骨牌覆盖，且每个多米诺骨牌恰好覆盖两个格子。
棋盘覆盖算法是一个NP难问题，它需要在指数时间内找到最佳解决方案。
但是，对于许多小规模的问题，我们可以使用回溯算法来得到最佳解决方案。
回溯算法是一种试探性算法，最初解答第一个问题，可进一步解答其他问题。
该算法探讨所有可能的解决方案，直到找到正确的方案。
如果没有正确的解决方案，那么回溯算法将返回到较早的步骤并尝试其他方案。
因此，我们可以使用回溯算法来解决这个问题。
当我们覆盖一个多米诺骨牌时，我们可以检查是否存在其他多米诺骨牌可以覆盖未覆盖的部分，并将这些多米诺骨牌添加到棋盘的布局中。
如果我们在棋盘上填好所有的多米诺骨牌，那么我们就找到了正确的解决方案。
步骤：1. 首先在棋盘上选择一个没有被覆盖的格子。
2. 从所有可以放置在这个格子上的多米诺骨牌中，选择一个多米诺骨牌放到这个位置上。
3. 如果这个多米诺骨牌可以被放置在棋盘上的其他未被覆盖的位置上，那么就在这个位置上放置。
4. 重复步骤2和3，一直到所有的多米诺骨牌都被放置在棋盘上。
5. 如果无法放置更多的多米诺骨牌了，那么我们就找到了一个正确的解决方案。
如果仍有多米诺骨牌没有被放置，那么我们就返回步骤2，并尝试用其他的多米诺骨牌进行覆盖。
6. 最终，我们找到的正确的解决方案就是把所有多米诺骨牌都放置在位置上的布局。
总之，棋盘覆盖算法是一个重要的问题，它在计算机科学领域中具有广泛的应用。
在实际应用中，我们可以使用计算机来解决这个问题，例如利用回溯算法。
棋盘覆盖问题的算法实现(代码及截图)
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
计算机算法设计与分析期末考试复习题
计算机算法设计与分析期末考试复习题1、二分搜索算法是利用（A）实现的算法。
A、分治策略B、动态规划法C、贪心法D、回溯法2、下列不是动态规划算法基本步骤的是（A）。
A、找出最优解的性质B、构造最优解C、算出最优解D、定义最优解3、最大效益优先是（A）的一搜索方式。
A、分支界限法B、动态规划法C、贪心法D、回溯法4、最长公共子序列算法利用的算法是（B）。
A、分支界限法B、动态规划法C、贪心法D、回溯法5.回溯法解TSP问题时的解空间树是（A）。
A、子集树B、排列树C、深度优先生成树D、广度优先生成树6．下列算法中通常以自底向上的方式求解最优解的是（B）。
A、备忘录法B、动态规划法C、贪心法D、回溯法7、衡量一个算法好坏的标准是（C）。
A运行速度快B占用空间少C时间复杂度低D代码短8、以下不可以使用分治法求解的是（D）。
9.实现循环赛日程表利用的算法是（A）。
A、分治策略B、动态规划法C、贪心法D、回溯法10、实现最长公共子序列利用的算法是（B）。
A、分治策略B、动态计划法C、贪心法D、回溯法11．下面不是分支界限法搜索方式的是（D）。
A、广度优先B、最小耗费优先C、最大效益优先D、深度优先12．下列算法中通常以深度优先方式系统搜索问题解的是（D）。
A、备忘录法B、动态规划法C、贪心法D、回溯法13.一个问题可用动态规划算法或贪心算法求解的关键特征是问题的（B）。
A、重叠子问题B、最优子结构性质C、贪心选择性质D、定义最优解14．广度优先是（A）的一搜索方式。
A、分支界限法B、动态规划法C、贪心法D、回溯法15．背包问题的贪心算法所需的计算时间为（B）。
A、O（n2）nB、O（nlogn）C、O（2）nD、O（n）16．实现最大子段和利用的算法是（B）。
A、分治策略B、动态规划法C、贪心法D、回溯法17．实现棋盘覆盖算法利用的算法是（A）。
A、分治法B、动态规划法C、贪心法D、回溯法18.下面是贪心算法的基本要素的是（C）。
算法分析与设计(参考题及答案
A、找出最优解的性质 B、构造最优解
C、算出最优解 D、定义最优解
答案：A
27.对完全二叉树自顶向下，从左向右给节点编号，节点编号为10的父节点编号为（ ）．
A、0 B、2 C、4 D、6
答案：C
28.下面哪种函数是回溯法中为避免无效搜索采取的策略（）
3.贪婪技术并不能够总是找到最优解。
A、正确 B、错误 答案：正确
4.对于任何权重的图，Dijkstra算法总能产生一个正确的解。
A、正确 B、错误 答案：错误
5.对于给定的字符表及其出现的概率，哈夫曼编码是唯一的。
A、正确 B、错误 答案：错误
6.贪婪算法是在每一步中，“贪婪”地选择最佳操作，并希望通过一系列局部的最优选择， 能产生一个整个问题的最优解。
一、单选题 1.下列函数关系随着输入量增大增加最快的是（ ）
A、log2n B、n2 C、2n D、n!
答案：C
2.实现循环赛日程表利用的算法是（）。
A、分治策略 B、动态规划法 C、贪心法 D、回溯法
答案：A
3.最长公共子序列算法利用的算法是（）。
A、分支界限法 B、动态规划法 C、贪心法 D、回溯法
答案：某个问题的最优解包含着其子问题的最优解。这种性质称为最优子结构性质。
3.简述动态规划方法所运用的最优化原理。
答案：“最优化原理”用数学化的语言来描述：假设为了解决某一优化问题，需要依次作出n个决策D1，D2，…，Dn，如若这 个决策序列是最优的，对于任何一个整数k，1<k<n，不论前面k个决策是怎样的，以后的最优决策只取决于由前面决策所确定 的当前状态，即以后的决策Dk+1，Dk+2，…，Dn也是最优的。
棋盘覆盖实验报告心得(3篇)
第1篇一、实验背景棋盘覆盖实验是计算机科学中一个经典的算法问题，旨在研究如何用最少数量的棋子覆盖整个棋盘。
这个实验不仅考验了我们对算法和数据结构的理解，还锻炼了我们的逻辑思维和编程能力。
在本实验中，我选择了使用回溯算法来解决棋盘覆盖问题，以下是我在实验过程中的心得体会。
二、实验目的1. 理解棋盘覆盖问题的背景和意义；2. 掌握回溯算法的基本原理和应用；3. 提高编程能力和逻辑思维能力；4. 分析不同算法的优缺点，为实际应用提供参考。
三、实验过程1. 确定问题模型棋盘覆盖问题可以抽象为一个二维数组，其中每个元素代表棋盘上的一个格子。
我们需要使用棋子（如皇后）来覆盖整个棋盘，使得每个格子都被至少一个棋子覆盖。
在本实验中，我们选择使用N皇后问题作为棋盘覆盖问题的子问题。
2. 设计算法为了解决棋盘覆盖问题，我们可以采用回溯算法。
回溯算法的基本思想是从一个解空间中搜索解，当找到一个解时，将其输出；当发现当前解不满足条件时，回溯到上一个状态，尝试其他可能的解。
具体步骤如下：（1）初始化棋盘，将所有格子设为未覆盖状态；（2）从第一行开始，尝试将棋子放置在该行第一个格子；（3）判断放置棋子后是否满足约束条件，如冲突、越界等；（4）如果满足约束条件，将该格子设为已覆盖状态，继续放置下一行棋子；（5）如果当前行已放置完棋子，检查是否覆盖了整个棋盘；（6）如果覆盖了整个棋盘，输出解；否则，回溯到上一个状态，尝试其他可能的解。
3. 编写代码根据上述算法，我使用Python语言实现了棋盘覆盖问题的回溯算法。
在代码中，我定义了一个二维数组来表示棋盘，并实现了放置棋子、检查约束条件、回溯等功能。
4. 实验结果与分析通过实验，我发现以下结论：（1）随着棋盘大小的增加，回溯算法的搜索空间也随之增大，导致算法的运行时间显著增加；（2）在解决N皇后问题时，当棋盘较大时，回溯算法的效率较低；（3）通过优化算法，如剪枝，可以提高算法的效率。
算法练习题-分章节-带答案
)算法练习题-分章节-带答案算法练习题---算法概述一、选择题1、下面关于算法的描述，正确的是（）A、一个算法只能有一个输入B、算法只能用框图来表示C、一个算法的执行步骤可以是无限的D、一个完整的算法，不管用什么方法来表示，都至少有一个输出结果2、一位爱好程序设计的同学，想通过程序设计解决“韩信点兵”的问题，他制定的如下工作过程中，更恰当的是（）A、设计算法，编写程序，提出问题，运行程序，得到答案B、分析问题，编写程序，设计算法，运行程序，得到答案C、分析问题，设计算法，编写程序，运行程序，得到答案D、设计算法，提出问题，编写程序，运行程序，得到答案3、下面说法正确的是（）A、算法+数据结构=程序B、算法就是程序C、数据结构就是程序D、算法包括数据结构4、衡量一个算法好坏的标准是（）。
A、运行速度快B、占用空间少C、时间复杂度低D、代码短5、解决一个问题通常有多种方法。
若说一个算法“有效”是指( )。
A、这个算法能在一定的时间和空间资源限制内将问题解决B、这个算法能在人的反应时间内将问题解决C、这个算法比其他已知算法都更快地将问题解决D、A和C6、算法分析中，记号O表示（），记号Ω表示（）。
A.渐进下界B.渐进上界C.非紧上界D.非紧下界7、以下关于渐进记号的性质是正确的有：（）A.f(n)(g(n)),g(n)(h(n))f(n)(h(n))=Θ=Θ⇒=ΘB.f(n)O(g(n)),g(n)O(h(n))h(n)O(f(n))==⇒=C. O(f(n))+O(g(n)) = O(min{f(n),g(n)})D.f(n)O(g(n))g(n)O(f(n))=⇔=8、记号O的定义正确的是（）。
A. O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n≥n0有：0≤ f(n) ≤ cg(n) }；B. O(g(n)) = { f(n) | 存在正常数c和n0使得对所有n≥n0有：0≤ cg(n) ≤ f(n) }；C. O(g(n)) = { f(n) | 对于任何正常数c>0，存在正数和n0 >0使得对所有n≥n0有0 ≤f(n)<cg(n) }；D. O(g(n)) = { f(n) | 对于任何正常数c>0，存在正数和n0 >0使得对所有n≥n0有：0 ≤cg(n) < f(n) }；9、记号Ω的定义正确的是（）。
算法选择题(初级版 )256道
算法选择题（初级版）256道1.二分搜索算法是利用（）实现的算法。
[单选题] *A.分治策略(正确答案)B.动态规划法C.贪心法D.回溯法2.回溯法解旅行售货员问题时的解空间树是（）。
[单选题] *A.子集树B.排列树(正确答案)C.深度优先生成树D.广度优先生成树3.下列算法中通常以自底向上的方式求解最优解的是（）。
[单选题] *A.备忘录法B.动态规划法(正确答案)C.贪心法D.回溯法4.下面不是分支界限法搜索方式的是（）。
[单选题] *A.广度优先B.最小耗费优先C.最大效益优先D.深度优先(正确答案)5.采用贪心算法的最优装载问题的主要计算量在于将集装箱依其重量从小到大排序，故算法的时间复杂度为（）。
[单选题] *A.O（n2^n）B.O（nlogn)(正确答案)C.O（2^n）D.O（n）6. 分支限界法求解最大团问题时，活结点表的组织形式是（）。
[单选题] *A.最小堆B.最大堆(正确答案)C.栈D.数组7. 下面问题（）不能使用贪心法解决。
[单选题] *A.单源最短路径问题B.N皇后问题(正确答案)C.最小花费生成树问题D.背包问题8. 下列算法中不能解决0/1 背包问题的是（）。
[单选题] *A.贪心法(正确答案)B.动态规划C.回溯法D.分支限界法9. 背包问题的贪心算法所需的计算时间为（）。
[单选题] *A.O（n2n）B.O（nlogn）(正确答案)C.O（2n）D.O（n）10. 二分查找是利用（）实现的算法。
[单选题] *A. 分治策略(正确答案)B. 动态规划法C. 分支限界法D. 概率算法11. 下列不是动态规划算法基本步骤的是（）。
[单选题] *A.找出最优解的性质B.构造最优解(正确答案)C.算出最优解D.定义最优解12. 最大效益优先是（）的一种搜索方式。
[单选题] *A.分支界限法(正确答案)B.动态规划法C.贪心法D.回溯法13. 在下列算法中有时找不到问题解的是（）。
算法设计复习题
一、单选题1、下面关于算法的描述，正确的是（d ）A、一个算法只能有一个输入B、算法只能用框图来表示C、一个算法的执行步骤可以是无限的D、一个完整的算法，不管用什么方法来表示，都至少有一个输出结果2、一位爱好程序设计的同学，想通过程序设计解决“韩信点兵”的问题，他制定的如下工作过程中，更恰当的是（c ）A、设计算法，编写程序，提出问题，运行程序，得到答案B、分析问题，编写程序，设计算法，运行程序，得到答案C、分析问题，设计算法，编写程序，运行程序，得到答案D、设计算法，提出问题，编写程序，运行程序，得到答案3、有5位运动员100米成绩依次为13.8，12.5，13.0，13.2，13.4，（c）若采用选择排序算法对其进行从小到大排序，则第二趟的排序结果是(A) 12.5 13.8 13.2 13.4 13.0 (B) 12.5 13.4 13.2 13.8 13.0(C) 12.5 13.0 13.8 13.2 13.4 (D) 12.5 13.2 13.8 13.4 13.04、下面说法正确的是（a ）A、算法+数据结构=程序B、算法就是程序C、数据结构就是程序D、算法包括数据结构5、数列1，4，7，10，13，……的递推公式为( d )。
(A) f(1)=1;f(n)=n+3 (B) f(1)=1;f(n)=n*2-1(C) f(1)=1;f(n)=n*2+1 (D) f(1)=1;f(n)=f(n-1)+36、用选择排序法对数据7，6，3，9，2从大到小排序，共需经过多少次数据对调。
a(A) 3 (B) 4 (C) 5 (D) 107、动态规划算法的基本要素为（c ）。
A、最优子结构性质与贪心选择性质B、重叠子问题性质与贪心选择性质C、最优子结构性质与重叠子问题性质D.、预排序与递归调用8、算法分析中，记号O表示（ b ），记号Ω表示（a），记号Θ表示（d ）。
A、渐进下界B、渐进上界C、非紧上界D、紧渐进界E、非紧下界9、以下关于渐进记号的性质是正确的有：（a）A、f(n)(g(n)),g(n)(h(n))f(n)(h(n))=Θ=Θ⇒=ΘB、f(n)O(g(n)),g(n)O(h(n))h(n)O(f(n))==⇒=C、O(f(n))+O(g(n)) = O(min{f(n),g(n)})D、f(n)O(g(n))g(n)O(f(n))=⇔=10、下列算法中通常以自底向上的方式求解最优解的是（ b ）。
棋盘覆盖问题
棋盘覆盖问题
有一个经典问题：8*8的棋盘，去掉了左下角和右上角2个格子，请问能否用31块1*2的骨牌覆盖整个棋盘。
这个问题的答案应该人人都知道吧，染色之后一目了然。
那么，有人要问了：如果去掉的是1红1白的格子各一个，结果是怎样的呢？比如下面的这个图：
你可以自己画几个图试一试。
你能证明一定可以覆盖？还是可以给出反例呢？
据说，这个问题刚出来的时候，通过复杂的理论，终于得到了证明。
也就是只要在这个图中去掉一红一白两格，肯定可以被覆盖。
这里，我们将看到一个复杂的问题怎么通过一个简单的方法来证明。
我们接下来不但要证明可以覆盖，而且要给出覆盖的方法。
看到这里你可能会想到了：构造——对了，只要构造了一组解，原问题便解决了。
我们把原来的棋盘按照下图所示的方法剪开：（沿着绿线）：
我们就把这个棋盘变成了一个环。
注意到整个环都是红白相间的。
假设我们从图中去掉一个红色格子，再去掉一个白色格子。
我们就得到两条链：每一条链都是红色->白色->红色...->白色。
这样我们只要沿着链每次的两个格子放即可（注意到相连的两个格子不存在和骨牌形状不同的情况：1*2，你能找出第二种形状吗？）。
把两条链放完，这个棋盘就被覆盖满了，我们的问题也就解决了。
棋盘覆盖问题
分治法棋盘覆盖声明：本文使用的代码和例子的来源：《计算机算法设计与分析》（王晓东编著，电子工业出版社）。
我对代码做了少许修改，使可以在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();}。
棋盘覆盖算法
棋盘覆盖算法
棋盘覆盖算法是一种经典的计算机算法，主要用于解决棋盘覆盖问题。
棋盘覆盖问题是指，将一个大小为2的幂次方的棋盘分成若干个大小为2的幂次方的小棋盘，然后选择其中一个小棋盘覆盖一个方块，直到所有方块都被覆盖。
具体规则是，每次覆盖一个小棋盘，然后将其他小棋盘划分成4个等分的小棋盘，其中一个小棋盘被覆盖，而其他小棋盘继续重复这个过程，直到所有方块都被覆盖。
棋盘覆盖算法可以采用分治算法的思想，将棋盘分成四个小区域，然后递归地解决每个小区域的棋盘覆盖问题。
每个小区域可以采用类似的方法继续划分，直到小棋盘的大小为1。
然后根据特定规则选择一个小棋盘进行覆盖，再递归地解决其他小区域的棋盘覆盖问题。
棋盘覆盖算法的时间复杂度为O(n^2)，其中n为棋盘的大小。
虽然该算法的复杂度比较高，但是它可以解决一些实际问题，比如图像识别、计算机视觉等。
- 1 -。
棋盘覆盖实验报告
实验报告课程名称算法分析与设计实验项目名称棋盘覆盖算法设计与实现班级与班级代码14251102202实验室名称（或课室）实验楼802 专业计算机科学与技术任课教师李绍华学号：14251102202姓名：陈晓俊实验日期：2016年10月27日广东商学院教务处制姓名实验报告成绩评语：指导教师（签名）年月日说明：指导教师评分后，实验报告交院（系）办公室保存。
一、实验目的1、理解算法的概念2、实现棋盘化以及棋盘覆盖3、理解递归与分治策略算法4、能够用Java语言实现该算法二、实验设备硬件：计算机一台软件：Windows 7操作系统、eclipse Java编程软件三、问题与算法描述1、问题描述在一个2^k×2^k （k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格，且称该棋盘为一个特殊棋盘。
在棋盘覆盖问题中，要用4种不同形态的L型骨牌覆盖给定的特异盘上除特殊方格以外所有方格，且任何2个L型骨牌不得重叠覆盖。
2、算法描述当k>0时 将2^k×2^k 棋盘分割为4个2k-1×2k-1 子棋盘。
特殊方格必位于4个较小子棋盘之一中，其余3个子棋盘中无特殊方格。
为了将这3个无特殊方格的子棋盘转化为特殊棋盘可以用一个L型骨牌覆盖，从而将原问题转化为4个较小规模的棋盘覆盖问题。
递归地使用这种分割直至棋盘简化为棋盘1×1。
3、算法时间复杂性分析从算法的分割策略可知，此算法的时间复杂度如下递归方程所示：)1()1(40)1({)(>+-==k o k T k o k T解此递归方程可得：)4()(k o k T =。
由于覆盖2^k ×2^k 棋盘所需的L 型骨牌个数为3/14k ）（-，所以这个算法是一个渐进意义的最优算法。
四、实验结果 1、当k=0时：2、当k>0时: 例如k=3时：例如k=5时：。
棋盘覆盖问题 C语言
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;
// 覆盖本子棋盘中的其余方格
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的：用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();}}}}五．程序运行结果（测试数据和运行结果）。