棋盘覆盖

合集下载

棋盘覆盖算法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();}}}}五.程序运行结果(测试数据和运行结果)。

五年级奥数讲义:棋盘中的数学(含答案)

五年级奥数讲义:棋盘中的数学(含答案)

五年级奥数讲义:棋盘中的数学(含答案)1.棋盘中的图形与面积;2.棋盘中的覆盖问题:(1)概念:用某种形状的卡片,按一定要求将棋盘覆盖住,就是棋盘的覆盖问题。

实际上,这里并不要求一定是某种棋盘,只要是有关覆盖若干行、若干列的方格网的问题,就是棋盘的覆盖问题。

(2)分类:棋盘的覆盖问题可以分为三类,一是能不能覆盖的问题,二是最多能用多少种图形覆盖的问题,三是有多少种不同的覆盖方法问题。

(3)重要结论:① m×n 棋盘能被2×1 骨牌覆盖的条件是m、n中至少有一个是偶数.② 2×n 的方格棋盘能用形骨牌覆盖的条件是3|n.3、棋盘中的象棋问题:所谓棋盘,常见的有中国象棋棋盘(下图(1)),围棋盘(下图(2)),还有国际象棋棋盘(下图(3)).以这些棋盘为背景而提出的问题统称为棋盘问题。

这里面与数学推理、计算相关的棋盘问题,就叫做棋盘中的数学问题。

解决棋盘中的数学问题所使用的数学知识,统称棋盘中的数学。

1、利用卡片覆盖已知图形,掌握一是能不能覆盖的问题,二是最多能用多少种图形覆盖的问题,三是有多少种不同的覆盖方法问题;2、利用象棋知识寻找路线;例1 一种骨牌是由形如的一黑一白两个正方形组成,则下图中哪个棋盘不能用这种骨牌不重复地完全覆盖?(A)3×4 (B)3×5 (C)4×4(D)4×5 (E)6×3答案:通过试验,很容易看到,应选择答案(B).分析:这类问题,容易更加一般化,即用2×1的方格骨牌去覆盖一个m×n的方格棋盘的问题.定理1: m×n棋盘能被2×1骨牌覆盖的充分且必要的条件是m、n中至少有一个是偶数.例2 下图中的8×8棋盘被剪去左上角与右下角的两个小方格,问能否用31个2×1的骨牌将这个剪残了的棋盘盖住?答案:我们将残角棋盘黑、白相间染色(如图),62个格中有黑格 32个,白格 30个.另外,如果用2×1骨牌 31张恰能盖住这个残角棋盘,我们发现,每个骨牌必定盖住一个黑格,一个白格,31个骨牌将盖住31个黑格及31个白格.这与32个黑格数,30个白格数的事实相矛盾.所以,无论如何用这31张2×1的骨牌盖不住这个残角棋盘.分析刚一想,31个2×1骨牌恰有62个小方格,棋盘去掉两个角后也是62个格,好像很有可能盖住.但只要简单一试,便发现不可能.仔细分析,发现如果把棋盘格黑、白相间染色后,2×1骨牌一次只能盖住一个黑格与一个白格.只要发现这个基本事实立即可以找到解答.例3 在下图(1)、(2)、(3)、(4)四个图形中:答案:图形(1)和(2)中各有11个方格,11不是3的倍数,因此不能用这两种图形拼成.图形来拼.只有图形(4)可以用这两种三个方格的图形来拼,具体拼法有多种,下图仅举出一种为例.分析:这道类型题用排除法,排除图(1)与(2)的方法是很重要的.因为一个图形可以用这是“必要条件排除法”.但要注意,一个图形小方格数是3的倍数,但是呢也不表明的就是这种情况.n|3。

五年级奥数讲义:棋盘中的数学(含答案)

五年级奥数讲义:棋盘中的数学(含答案)

五年级奥数讲义:棋盘中的数学(含答案)1.棋盘中的图形与面积;2.棋盘中的覆盖问题:(1)概念:用某种形状的卡片,按一定要求将棋盘覆盖住,就是棋盘的覆盖问题.实际上,这里并不要求一定是某种棋盘,只要是有关覆盖若干行、若干列的方格网的问题,就是棋盘的覆盖问题.(2)分类:棋盘的覆盖问题可以分为三类,一是能不能覆盖的问题,二是最多能用多少种图形覆盖的问题,三是有多少种不同的覆盖方法问题.(3)重要结论:① m×n 棋盘能被2×1 骨牌覆盖的条件是m、n中至少有一个是偶数.② 2×n 的方格棋盘能用形骨牌覆盖的条件是3|n.3、棋盘中的象棋问题:所谓棋盘,常见的有中国象棋棋盘(下图(1)),围棋盘(下图(2)),还有国际象棋棋盘(下图(3)).以这些棋盘为背景而提出的问题统称为棋盘问题.这里面与数学推理、计算相关的棋盘问题,就叫做棋盘中的数学问题.解决棋盘中的数学问题所使用的数学知识,统称棋盘中的数学.1、利用卡片覆盖已知图形,掌握一是能不能覆盖的问题,二是最多能用多少种图形覆盖的问题,三是有多少种不同的覆盖方法问题;2、利用象棋知识寻找路线;例1 一种骨牌是由形如的一黑一白两个正方形组成,则下图中哪个棋盘不能用这种骨牌不重复地完全覆盖?(A)3×4 (B)3×5 (C)4×4(D)4×5 (E)6×3答案:通过试验,很容易看到,应选择答案(B).分析:这类问题,容易更加一般化,即用2×1的方格骨牌去覆盖一个m×n的方格棋盘的问题.定理1: m×n棋盘能被2×1骨牌覆盖的充分且必要的条件是m、n中至少有一个是偶数.例2 下图中的8×8棋盘被剪去左上角与右下角的两个小方格,问能否用31个2×1的骨牌将这个剪残了的棋盘盖住?答案:我们将残角棋盘黑、白相间染色(如图),62个格中有黑格 32个,白格 30个.另外,如果用2×1骨牌 31张恰能盖住这个残角棋盘,我们发现,每个骨牌必定盖住一个黑格,一个白格,31个骨牌将盖住31个黑格及31个白格.这与32个黑格数,30个白格数的事实相矛盾.所以,无论如何用这31张2×1的骨牌盖不住这个残角棋盘.分析刚一想,31个2×1骨牌恰有62个小方格,棋盘去掉两个角后也是62个格,好像很有可能盖住.但只要简单一试,便发现不可能.仔细分析,发现如果把棋盘格黑、白相间染色后,2×1骨牌一次只能盖住一个黑格与一个白格.只要发现这个基本事实立即可以找到解答.例3 在下图(1)、(2)、(3)、(4)四个图形中:答案:图形(1)和(2)中各有11个方格,11不是3的倍数,因此不能用这两种图形拼成.图形来拼.只有图形(4)可以用这两种三个方格的图形来拼,具体拼法有多种,下图仅举出一种为例.分析:这道类型题用排除法,排除图(1)与(2)的方法是很重要的.因为一个图形可以用这是“必要条件排除法”.但要注意,一个图形小方格数是3的倍数,但是呢也不表明的就是这种情况.n|3.答案:当3|n时,设n=3k,则2×n=2×3k=k(2×3)2×n=3×x则3|2n,但(2,3)=1,∴3|n.分析:思考方法.比如,若3|n且2|m时, m×n棋盘可分成若干个2×n棋例5、这是一个中国象棋盘,(下图中小方格都是相等的正方形,“界河”的宽等于小正方形边长).黑方有一个“象”,它只能在1,2,3,4,5,6,7位置中的一个,红方有两个“相”,它们只能在8, 9, 10, 11, 12, 13, 14中的两个位置.问:这三个棋子(一个黑“象”和两个红“相”)各在什么位置时,以这三个棋子为顶点构成的三角形的面积最大?答案:黑“象”在2或3的位置,两个红“相”分别在 10,12的位置时,以这三个棋子为顶点的三角形(2,10,12)或(3,10,12)的面积最大,如下图所示.分析:我们设每个小方格的边长为1单位.则小方格正方形面积为1平方单位.由于三个顶点都在长方形边上的三角形面积至多为这个长方形面积的一半.所以要比较三角形面积的大小,只要比较三角形的三个顶点所在边的外接长方形面积的大小就可见端倪.直观可见,只须比较(3,10,12)或(2,10,12)与(3,10,13)或(2,12,14)这两类三角形面积就可以了.顶点为(3,10,13)或(2,12,14)的三角形面积等于:所以顶点在(2,10,12)或(3,10,12)时三角形面积最大.例6、如下图是半张棋盘,请你用两个车、两个马、两个炮、一个相和一个兵这八个子放在这半个棋盘上,使得其余未被占据的点都在这八个点的控制之下(要符合象棋规则,“相”走田字,只能放在“相”所能到的位置,同样“兵”也只能放在“兵”所能到的位置.马走“日”字,“车”走直线,“炮”隔子控制等).答案:这仍是一个占位问题,只需要把指出的几个子排布成所要求的阵势即可,如下图所示.分析:主要考查棋盘中的覆盖问题:完全覆盖问题.只要把每个棋的走法掌握该类型题应该没有太大问题.A档1、在4×4 的正方形中,至少要放多少个形如所示的卡片,才能使得在不重叠的情形下,不能再在正方形中多放一个这样的卡片?(要求卡片的边缘与格线重合)答案与提示:3 个.提示:右图是一种放法.2、能否用9 个形如的卡片覆盖6×6 的棋盘?答案与提示:不能.右图中黑、白格各18 个,每张卡片盖住的黑格数是奇数,9 张卡片盖住的黑格数之和仍是奇数,不可能盖住18 个黑格.3、有若干个边长为1、边长为2、边长为3 的小正方形,从中选出一些拼成一个边长为4 的大正方形,共有多少种不同拼法?(只要选择的各种小正方形的数目相同就算相同的拼法)答案与提示: 6 种.用小正方形拼成边长为4 的大正方形有6 种情形:(1)1 个3×3,7 个1×1;(2)1 个2×2,12 个1×1;(3)2 个2×2,8 个1×1;(4)3 个2×2,4 个1×1;(5)4 个2×2;(6)16 个1×1.B档4、要不重叠地刚好覆盖住一个正方形,最少要用多少个右图所示的图形?答案与提示:因为图形由3个小方格构成,所以要拼成的正方形内所含的小方格数应是3的倍数,从而正方形的边长应是3的倍数.经试验,不可能拼成边长为3的正方形.所以拼成的正方形的边长最少是6(见右图),需要用题目所示的图形36÷3= 12(个).5、下图的七种图形都是由4个相同的小方格组成的.现在要用这些图形拼成一个4×7的长方形(可以重复使用某些图形),那么,最多可以用上几种不同的图形?答案与提示:先从简单的情形开始考虑.显然,只用1种图形是可以的,例如用7个(7);用2种图形也没问题,例如用1个(7),6个(1).经试验,用6种图形也可以拼成4×7的长方形(见下图).能否将7种图形都用上呢?7个图形共有4×7=28(个)小方格,从小方格的数量看,如果每种图形用1个,那么有可能拼成4×7的长方形.但事实上却拼不成.为了说明,我们将4×7的长方形黑、白相间染色(见右图),图中黑、白格各有14个.在7种图形中,除第(2)种外,每种图形都覆盖黑、白格各2个,共覆盖黑、白格各12个,还剩下黑、白格各2个.第(2)种图形只能覆盖3个黑格1个白格或3个白格1个黑格,因此不可能覆盖住另6种图形覆盖后剩下的2个黑格2个白格.综上所述,要拼成 4×7的长方形,最多能用上 6种图形.6、用1×1,2×2,3×3的小正方形拼成一个11×11的大正方形,最少要用1×1的正方形多少个?答案与提示:用3个2×2正方形和2个3×3正方形可以拼成1个5×6的长方形(见左下图).用4个5×6的长方形和1 个 1×1的正方形可以拼成 1个11×11的大正形(见右下图).上面说明用1个1×1的正方形和若干2×2,3×3的正方形可以拼成 11×11的大正方形.那么,不用1×1的正方形,只用2×2,3×3的正方形可以拼成11×11的正方形吗?将11×11的方格网每隔两行染黑一行(见下页右上图).将2×2或3×3的正方形沿格线放置在任何位置,都将覆盖住偶数个白格,所以无论放置多少个2×2或3×3的正方形,覆盖住的白格数量总是偶数个.但是,右图中的白格有11×7=77(个),是奇数,矛盾.由此得到,不用1×1的正方形不可能拼成11×11的正方形.综上所述,要拼成11×11的正方形,至少要用1个1×1的小正方形.7、用七个1×2的小长方形覆盖下图,共有多少种不同的覆盖方法?答案与提示:盲目无章的试验,很难搞清楚.我们采用分类讨论的方法.如下图所示,盖住A所在的小格只有两种情况,其中左下图中①②两个小长方形只能如图覆盖,其余部分有4种覆盖方法:右下图中①②③三个小长方形只能如图覆盖,其余部分有3种覆盖方法.所以,共有7种不同覆盖方法.8、有许多边长为1厘米、2厘米、3厘米的正方形硬纸片.用这些硬纸片拼成一个长5厘米、宽3厘米的长方形的纸板,共有多少种不同的拼法?(通过旋转及翻转能相互得到的拼法认为是相同的拼法)答案与提示:有一个边长3厘米纸片有如下3种拼法:有两个边长2厘米纸片的有如下4种拼法:有一个边长2厘米及11个边长1厘米纸片的有2种拼法,边长全是1 厘米纸片的有1种拼法.共有不同的拼法3+4+2+1=10(种).答:共有10种不同的拼法.C档9、小明有8张连在一起的电影票(如右图),他自己要留下4张连在一起的票,其余的送给别人.他留下的四张票可以有多少种不同情况?答案与提示:25种.形如图(A)(B)(C)(D)的依次有3,10,6,6种.10、有若干个边长为1、边长为2、边长为3的小正方形,从中选出一些拼成一个边长为4的大正方形,共有多少种不同拼法?(只要选择的各种小正方形的数目相同就算相同的拼法)答案与提示:6种.用小正方形拼成边长为4的大正方形有6种情形:(1)1个3×3,7个1×1;(2)1个2×2,12个1×1;(3)2个2×2,8个1×1;(4)3个2×2,4个1×1;(5)4个2×2;(6)16个1×1.11、能不能用9个1×4的长方形卡片拼成一个6×6的正方形?答案与提示:不能.用1,2,3,4对6×6棋盘中的小方格编号(见右图).一个1×4的矩形一次只能覆盖1,2,3,4号各一个,而1,2,3,4号数目不等,分别有9,10,9,8个.12、一种游戏机的“方块”游戏中共有如下页图所示的七种图形,每种图形都由4个面积为1的小方格组成.现用7个这样的图形拼成一个7×4的长方形(可以重复使用某些图形).那么,最多可以用上面七种图形中的几种?答案:要拼成4×7的方格,最多能用上七种“方块”中的6种图形13、由1×1、 2×2、3×3的小正方形拼成一个23×23的大正方形,在所有可能的拼法中,利用1×1的正方形最少个数是多少?试证明你的结论.答案:至少要用一个1×1的小正方形.14、如下左图是一个国际象棋棋盘,A处有只蚂蚁,蚂蚁只能由黑格进入白格再由白格进入黑格这样黑白交替地行走,已经走过的格子不能第二次进入.请问,蚂蚁能否从A出发,经过每个格子最后返回到A处?若能,请你设计一种路线,若不能,请你说明理由.解:这种爬行路线是存在的.具体的设计一条,如右图所示.15、下图是一个围棋盘,另有一堆围棋子,将这堆棋子往棋盘上放,当按格点摆成某个正方阵时,尚多余12枚棋子,如果要将这个正方阵改摆成每边各加一枚棋子的正方阵,则差9枚棋子才能摆满.问:这堆棋子原有多少枚?解:第一次排方阵剩余12枚,加上第二次排方阵所不足的9枚,恰是原正方阵扩大后“贴边”的部分(如下图所示),共21枚,它恰是原正方阵每边棋子数与“扩阵”每边棋子数之和.恰是两个相邻自然数之和,所以原正方阵每边10枚棋子,新正方阵每边11枚棋子.这堆棋子总数是102+12=112枚.答:这堆棋子原有112枚.1、如下左图是一个国际象棋棋盘,A处有只蚂蚁,蚂蚁只能由黑格进入白格再由白格进入黑格这样黑白交替地行走,已经走过的格子不能第二次进入.请问,蚂蚁能否从A出发,经过每个格子最后返回到A处?若能,请你设计一种路线,若不能,请你说明理由.答案:这种爬行路线是存在的.具体的设计一条,如右图所示.2、在8×8的方格棋盘中,如下图所示,填上了一些数字1,2,3,4.试将这个棋盘分成大小和形状都相同的四块,并且每块中都恰有1、2、3、4四个数字.答案:①将两个并列在一起的“4”分开,先画出这段划分线,并将它分别绕中心旋转90°,180°和270°,得到另外三段划分线,如下图(1)所示.②仿照上述方法,画出所有这样的划分线,如上图(2)所示.③从最里层开始,沿着画出的划分线作设想分块,如上图(3),这个分块中要含1,2,3,4各一个,且恰为16块小方格.④将上面的阴影部分绕中心旋转180°,可以得到符合条件的另一块,空白部分的两块也符合条件,所求的划分如上页图(4)所示3、要不重叠地刚好覆盖住一个正方形,最少要用多少个右图所示的图形?答案:84、一种游戏机的“方块”游戏中共有如下页图所示的七种图形,每种图形都由4个面积为1的小方格组成.现用7个这样的图形拼成一个8×4的长方形(可以重复使用某些图形).那么,最少可以用上面七种图形中的几种?答案:要拼成8×4的方格,最多能用上七种“方块”中的1种图形5、能不能用9个1×4的长方形卡片拼成一个12×3的正方形?答案与提示:能.1、要不重叠地刚好覆盖住一个正方形,最少要用多少个右图所示的图形?答案:122、一种游戏机的“方块”游戏中共有如下页图所示的七种图形,每种图形都由4个面积为1的小方格组成.现用7个这样的图形拼成一个8×4的长方形(可以重复使用某些图形).那么,最少可以用上面七种图形中的几种?答案:要拼成8×4的方格,最多能用上七种“方块”中的1种图形3、能不能用9个2×3的长方形卡片拼成一个7×8的正方形?答案与提示:不能.4、在不重叠的情形下,不能再在正方形中多放一个这样的卡片?(要求卡片的边缘与格线重合)答案:3个.提示:左下图是一种放法.5、答案:图(2).6、答案:不能.7、答案:5种.8、国际象棋的棋盘有64个方格,有一种威力很大的棋子叫“皇后”,当它放在某格上时,它能吃掉此格所在的斜线和直线上对方的棋子,如下左图上虚线所示.如果有五个“皇后”放在棋盘上,就能把整个棋盘都“管”住,不论对方棋子放在哪一格,都会被吃掉.请你想一想,这五个“皇后”应该放在哪几格上才能控制整个棋盘?答案:本题是构造性的题目.用五个子管住六十四格,如上右图所示就是一种放置皇后的方案.。

棋盘覆盖问题的求解

棋盘覆盖问题的求解

棋盘覆盖问题的求解棋盘覆盖问题是一个经典的数学问题,它引发了人们对于数学中的逻辑思维和问题解决能力的思考。

在这篇文章中,我将为大家详细介绍棋盘覆盖问题的求解方法,并希望能够帮助中学生和他们的父母更好地理解和应用这一问题。

棋盘覆盖问题是指如何用特殊形状的骨牌将一个2^n × 2^n的棋盘完全覆盖的问题。

其中,骨牌的形状分为4种,分别为L型、反L型、凸型和凹型。

在求解这个问题时,我们需要遵循以下几个步骤。

首先,我们需要将给定的棋盘划分为四个相等的小棋盘。

这样,我们就可以将问题分解为四个子问题,分别是将四个小棋盘覆盖完整。

接下来,我们就可以通过递归的方式来解决每个子问题。

在解决子问题时,我们需要根据骨牌的形状来选择放置的位置。

以L型骨牌为例,我们可以将其放置在左上角、左下角或者右上角。

通过不同的放置位置,我们可以将子问题进一步分解为更小的子问题。

同样地,我们可以使用相同的方法来解决反L型、凸型和凹型骨牌。

在每个子问题中,我们需要注意两个关键点。

首先,我们需要保证每个小棋盘上的骨牌能够完全覆盖。

这就要求我们在放置骨牌时,需要选择合适的位置和方向。

其次,我们需要保证四个小棋盘的边缘能够对齐。

这样,才能保证最终的结果是一个完整的棋盘。

通过不断地递归求解子问题,我们最终可以将整个棋盘完全覆盖。

这个过程中,我们需要注意边界条件的处理,以及递归函数的设计。

同时,我们还可以通过剪枝等优化方法来提高算法的效率。

棋盘覆盖问题的求解方法不仅仅是一个数学问题,更是一个思维训练的过程。

通过解决这个问题,我们可以培养自己的逻辑思维能力、问题解决能力和创新思维。

同时,这个问题也具有一定的实用性,可以用于解决一些实际问题,如图像处理、计算机视觉等领域。

总结一下,棋盘覆盖问题是一个经典的数学问题,通过将棋盘划分为四个小棋盘,我们可以通过递归的方式来解决每个子问题。

在解决子问题时,我们需要选择合适的骨牌形状和放置位置,同时保证边缘对齐和完全覆盖。

初中数学在实际生活中的应用案例 数形结合思想的应用

初中数学在实际生活中的应用案例 数形结合思想的应用

初中数学在实际生活中的应用案例数形结合思想的应用数学是一门应用广泛的学科,它不仅仅存在于课本和考试中,更贯穿于我们日常生活的方方面面。

在初中数学中,数形结合思想是一个重要的概念,它将数学与几何图形相结合,让我们能够更好地理解和应用数学知识。

本文将介绍一些初中数学在实际生活中的应用案例,重点聚焦于数形结合思想的应用。

案例一:棋盘覆盖问题在数学中,棋盘覆盖问题是一个经典的问题。

假设有一个8x8的棋盘,用2x1的骨牌完全覆盖该棋盘,共有多少种覆盖方法?我们可以利用数形结合思想解决这个问题。

首先,我们将2x1的骨牌看作一种特殊的图形单元,将这种单元覆盖在棋盘上。

由于每个2x1的骨牌占据两个单元,因此整个棋盘共有64/2=32个单元。

而每个骨牌可以垂直或水平放置,因此每个单元有两种可能的覆盖方式。

接下来,我们尝试利用数形结合思想进行推理。

考虑到棋盘的边界问题,我们可以发现,棋盘的右下角必须覆盖一块。

那么,我们可以把右下角单元放上一块骨牌。

这样,右下角单元被覆盖后,原棋盘被分成了两个部分:一个是7x8的矩形,另一个是1x8的窄矩形。

对于7x8的矩形,在数形结合思想的指导下,我们可以将问题转化为一个更小规模的棋盘覆盖问题。

同样地,我们可以继续将其右下角单元覆盖,然后将其分成两个部分。

如此反复,最终我们可以找到问题的解。

通过以上的推理过程,我们可以得出结论:棋盘覆盖问题的解法共有2的32次方种可能。

案例二:测量高楼高度在实际生活中,我们有时候需要测量一座高楼的高度,但是往往无法直接测量。

这时,我们可以利用数形结合思想进行近似测量。

假设我们站在离高楼一定距离的地方,并且竖直放置一个测距仪。

我们可以利用三角形的形状和几何定理,使用测距仪与我们所看到的高楼顶部的夹角,以及我们与测距仪之间的距离,来计算出高楼的高度。

首先,我们假设测距仪的底部位置为A,顶部位置为B,高楼的底部位置为C,顶部位置为D。

通过观察可以发现,三角形ABC和三角形ABD相似。

棋盘覆盖问题c语言

棋盘覆盖问题c语言
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,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)实验报告成绩按五级标准评分;精心搜集整理,只为你的需要

棋盘覆盖实验报告

int dimen;//棋盘规模
int x_pos;//特殊点横坐标
int y_pos;//特殊点竖坐标
Container p;
public MyChessBoard() {
super();
x_pos = 0;
y_pos = 0;
dimen = 0;
setTitle("棋盘覆盖");
setBackground(Color.YELLOW);
y = 0;}setLocation(x, y);}public void actionPerformed(ActionEvent e) {
if(e.getActionCommand()=="退出") {
System.exit
(0);}else if(e.getActionCommand()=="开始") {
x_pos = (int)(dimen*Math.random());//随机生成特殊点位置
y_pos = (int)(dimen*Math.random());
p.setLayout(new GridLayout(dimen, dimen));
System.out.println(x_pos+","+y_pos);
/**** @authorxxxx
*/
public class FenZi {
public static void main(String args[]){new MyChessBoard();}}
class MyChessBoard extends JFrame implements ActionListener {
for(int j=0; j<board[i].length; j++) {

分治法棋盘覆盖问题算法原理

分治法棋盘覆盖问题算法原理
分治法棋盘覆盖问题算法是一种基于分治策略的算法,用于解决棋盘覆盖问题。

该算法的基本原理是将一个复杂的问题分解为若干个较小的子问题,然后分别求解这些子问题,最后将子问题的解合并为原问题的解。

在棋盘覆盖问题中,给定一个n×n的棋盘,要求用最少的1×2骨牌覆盖整个棋盘。

分治法棋盘覆盖问题算法通过将棋盘不断划分,将问题规模逐渐减小,最终将问题转化为若干个1×1的棋盘覆盖问题,从而使得问题得以解决。

具体来说,该算法首先将棋盘划分为四个相等的子棋盘,然后判断哪个子棋盘中包含特殊方格。

对于不包含特殊方格的子棋盘,用L型骨牌覆盖其会合处,将其转化为特殊棋盘。

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

通过这种分治策略,算法可以将问题规模不断减小,直到每个子问题都能够被直接解决。

最终,所有子问题的解将被合并为原问题的解。

这种算法不仅具有高效性,而且能够将复杂的问题分解为若干个简单的子问题,使得问题的解决更加容易。

棋盘覆盖算法

棋盘覆盖算法棋盘覆盖算法(Tiling Puzzle)是用小的拼图块填满一个大的棋盘的问题,这些拼图块称作多米诺骨牌,每一块都覆盖两个格子,而棋盘的大小为2的n次方×2的n次方,其中n是整数。

在一个棋盘和一组多米诺骨牌下,棋盘恰好可以被所有的多米诺骨牌覆盖,且每个多米诺骨牌恰好覆盖两个格子。

棋盘覆盖算法是一个NP难问题,它需要在指数时间内找到最佳解决方案。

但是,对于许多小规模的问题,我们可以使用回溯算法来得到最佳解决方案。

回溯算法是一种试探性算法,最初解答第一个问题,可进一步解答其他问题。

该算法探讨所有可能的解决方案,直到找到正确的方案。

如果没有正确的解决方案,那么回溯算法将返回到较早的步骤并尝试其他方案。

因此,我们可以使用回溯算法来解决这个问题。

当我们覆盖一个多米诺骨牌时,我们可以检查是否存在其他多米诺骨牌可以覆盖未覆盖的部分,并将这些多米诺骨牌添加到棋盘的布局中。

如果我们在棋盘上填好所有的多米诺骨牌,那么我们就找到了正确的解决方案。

步骤:1. 首先在棋盘上选择一个没有被覆盖的格子。

2. 从所有可以放置在这个格子上的多米诺骨牌中,选择一个多米诺骨牌放到这个位置上。

3. 如果这个多米诺骨牌可以被放置在棋盘上的其他未被覆盖的位置上,那么就在这个位置上放置。

4. 重复步骤2和3,一直到所有的多米诺骨牌都被放置在棋盘上。

5. 如果无法放置更多的多米诺骨牌了,那么我们就找到了一个正确的解决方案。

如果仍有多米诺骨牌没有被放置,那么我们就返回步骤2,并尝试用其他的多米诺骨牌进行覆盖。

6. 最终,我们找到的正确的解决方案就是把所有多米诺骨牌都放置在位置上的布局。

总之,棋盘覆盖算法是一个重要的问题,它在计算机科学领域中具有广泛的应用。

在实际应用中,我们可以使用计算机来解决这个问题,例如利用回溯算法。

棋盘覆盖问题(算法竞赛入门经典)

棋盘覆盖问题(算法竞赛⼊门经典)在⼀个 2^k * 2^k 个⽅格组成的棋盘中,若恰有⼀个⽅格与其它⽅格不同,则称该⽅格为⼀特殊⽅格,称该棋盘为⼀特殊棋盘。

显然特殊⽅格在棋盘上出现的位置有 4^k 种情形。

因⽽对任何 k>=0 ,有 4^k 种不同的特殊棋盘。

下图所⽰的特殊棋盘为 k=2 时 16 个特殊棋盘中的⼀个。

在棋盘覆盖问题中,要⽤下图中 4 中不同形态的 L 型⾻牌覆盖⼀个给定的特殊棋牌上除特殊⽅格以外的所有⽅格,且任何 2 个 L 型⾻牌不得重叠覆盖。

易知,在任何⼀个 2^k * 2^k 的棋盘中,⽤到的 L 型⾻牌个数恰为 (4^k-1)/3 。

⽤分治策略,可以设计解棋盘问题的⼀个简捷的算法。

当 k>0 时,将 2^k * 2^k 棋盘分割为 4 个 2^(k-1) * 2^(k-1) ⼦棋盘,如下图所⽰。

特殊⽅格必位于 4 个较⼩⼦棋盘之⼀中,其余 3 个⼦棋盘中⽆特殊⽅格。

为了将这 3 个⽆特殊⽅格的⼦棋盘转化为特殊棋盘,我们可以⽤⼀个 L 型⾻牌覆盖这 3 个较⼩的棋盘的汇合处,如下图所⽰,这 3 个⼦棋盘上被 L 型⾻牌覆盖的⽅格就成为该棋盘上的特殊⽅格,从⽽将原问题化为 4 个较⼩规模的棋盘覆盖问题。

递归的使⽤这种分割,直⾄棋盘简化为 1x1 棋盘。

下⾯给出代码:1 #include<iostream>2 #include<string.h>3 using namespace std;4 int tile=1; //L型⾻牌的编号(递增)5 int board[100][100]; //棋盘6 /*****************************************************7 * 递归⽅式实现棋盘覆盖算法8 * 输⼊参数:9 * tr--当前棋盘左上⾓的⾏号10 * tc--当前棋盘左上⾓的列号11 * dr--当前特殊⽅格所在的⾏号12 * dc--当前特殊⽅格所在的列号13 * size:当前棋盘的:2^k14 *****************************************************/15 void chessBoard ( int tr, int tc, int dr, int dc, int size )16 {17 if ( size==1 ) //棋盘⽅格⼤⼩为1,说明递归到最⾥层18 return;19 int t=tile++; //每次递增120 int s=size/2; //棋盘中间的⾏、列号(相等的)21 //检查特殊⽅块是否在左上⾓⼦棋盘中22 if ( dr<tr+s && dc<tc+s ) //在23 chessBoard ( tr, tc, dr, dc, s );24 else //不在,将该⼦棋盘右下⾓的⽅块视为特殊⽅块25 {26 board[tr+s-1][tc+s-1]=t;27 chessBoard ( tr, tc, tr+s-1, tc+s-1, s );28 }29 //检查特殊⽅块是否在右上⾓⼦棋盘中30 if ( dr<tr+s && dc>=tc+s ) //在31 chessBoard ( tr, tc+s, dr, dc, s );32 else //不在,将该⼦棋盘左下⾓的⽅块视为特殊⽅块33 {34 board[tr+s-1][tc+s]=t;35 chessBoard ( tr, tc+s, tr+s-1, tc+s, s );36 }37 //检查特殊⽅块是否在左下⾓⼦棋盘中38 if ( dr>=tr+s && dc<tc+s ) //在39 chessBoard ( tr+s, tc, dr, dc, s );40 else //不在,将该⼦棋盘右上⾓的⽅块视为特殊⽅块41 {42 board[tr+s][tc+s-1]=t;43 chessBoard ( tr+s, tc, tr+s, tc+s-1, s );44 }45 //检查特殊⽅块是否在右下⾓⼦棋盘中46 if ( dr>=tr+s && dc>=tc+s ) //在47 chessBoard ( tr+s, tc+s, dr, dc, s );48 else //不在,将该⼦棋盘左上⾓的⽅块视为特殊⽅块49 {50 board[tr+s][tc+s]=t;51 chessBoard ( tr+s, tc+s, tr+s, tc+s, s );52 }53 }5455 int main()56 {57 int size;58 memset(board,0,sizeof(board));59 cout<<"输⼊棋盘的size(⼤⼩必须是2的n次幂): ";60 cin>>size;61 int index_x,index_y;62 cout<<"输⼊特殊⽅格位置的坐标: ";63 cin>>index_x>>index_y;64 cout<<board[index_x][index_y]<<endl;65 chessBoard ( 0,0,index_x,index_y,size );66 for ( int i=0; i<size; i++ )67 {68 for ( int j=0; j<size; j++ )69 cout<<board[i][j]<<' ';70 cout<<endl;71 }72 return 0;73 }。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++++++++++++ // test_project.cpp : 定义控制台应用程序的入口点。

// 棋盘覆盖
//将书上的算法进行了稍微的改进,减少if语句判断次数
#include"stdafx.h"
#include<iostream>
using namespace std;
int tile=0;//表示L型骨牌的编号
int Board[8][8]={0};//定义棋盘并初始化棋盘
void ChessBoard(int tr,int tc,int dr,int dc,int size);
void main()
{
cout<<"请输入特殊盘的下标号:"<<endl;
int x,y;
cin>>x>>y;
ChessBoard(0,0,x,y,8);
cout<<endl<<endl;
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
{
cout<<Board[i][j]<<" ";
}
cout<<endl;
}
}
void ChessBoard(int tr,int tc,int dr,int dc,int size) {//采用分治策略的棋盘算法
if(size==1)
return;
int t=++tile,//L型骨牌号
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;//覆盖右下角子棋盘的左上角
cout<<"第"<<t<<"次"<<"覆盖的L型标号为为:
"<<tr+s-1<<"-"<<tc+s
<<" : "<<tr+s<<"-"<<tc+s<<" :
"<<tr+s<<"-"<<tc+s-1<<endl;
ChessBoard(tr,tc,dr,dc,s);//覆盖左上角子棋盘
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);//覆盖右上角子棋盘
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);//覆盖左下角子棋盘
ChessBoard(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;
cout<<"第"<<t<<"次"<<"覆盖的L型标号为为:
"<<tr+s-1<<"-"<<tc+s-1
<<" : "<<tr+s<<"-"<<tc+s-1<<" :
"<<tr+s<<"-"<<tc+s<<endl;
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);//覆盖左上角子棋盘
ChessBoard(tr,tc+s,dr,dc,s);//覆盖右上角子棋盘 ChessBoard(tr+s,tc,tr+s,tc+s-1,s);//覆盖左下角子棋盘
ChessBoard(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;
cout<<"第"<<t<<"次"<<"覆盖的L型标号为为:
"<<tr+s-1<<"-"<<tc+s-1
<<" : "<<tr+s-1<<"-"<<tc+s<<" :
"<<tr+s<<"-"<<tc+s<<endl;
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);//覆盖左上角子棋盘
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);//覆盖右上角子棋盘
ChessBoard(tr+s,tc,dr,dc,s);//覆盖左下角子棋盘 ChessBoard(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-1]=t;
cout<<"第"<<t<<"次"<<"覆盖的L型标号为为:
"<<tr+s-1<<"-"<<tc+s
<<" : "<<tr+s-1<<"-"<<tc+s-1<<" :
"<<tr+s<<"-"<<tc+s-1<<endl;
}
else
cout<<"error!!!"<<endl; }。

相关文档
最新文档