连连看算法

合集下载

连连看算法

连连看所要求的是：1：两个目标是相同的2：两个目标之间连接线的折点不超过两个。

（连接线由x轴和y轴的平行线组成）那么分析一下连接的情况可以看到，一般分三种情况1：直线相连2：一个折点3：两个折点如图：可以发现，如果有折点，每个折点必定有且至少有一个坐标（x或者y）是和其中一个目标点是相同的，也就是说，折点必定在两个目标点所在的x方向或y方向的直线上。

所以设计思路就是：假设目标点p1 , p2 ,如果有两个折点分别为z1 , z2 那么，所要进行的是1：如果验证p1 , p2 直线连线，则连接成立2：搜索以p1,p2的x,y方向四条直线（可能某两条直线会重合）上的有限点，每次取两点作为z1,z2 ,验证p1到z1/z1到z2/z2到p2 是否都能直线相连，是则连接成立。

（如果z1=z2也就是只有一个折点喽，对判断没影响）那么程序算法上，这里先就理论进行一个试验var mmap=new Array();mmap[0]=new Array(0,0,0,0,0,0);mmap[1]=new Array(0,1,2,8,1,0);mmap[2]=new Array(0,5,5,4,3,0);mmap[3]=new Array(0,4,6,7,3,0);mmap[4]=new Array(0,8,2,6,7,0);mmap[5]=new Array(0,0,0,0,0,0);p1=new Array(1,4);p2=new Array(1,2);//定义一个二维数组作为游戏的映像，相同的数字代表相同的图标，0是空处，p1,p2是选择的点linelink=function(o1,o2){var t=new Array(0,0);if(o1[0]==o2[0] || o1[1]==o2[1]){if(Math.abs(o1[0]-o2[0])+Math.abs(o1[1]-o2[1])<=1){return true;}else{t[0]=isNaN((o2[0]-o1[0])/Math.abs(o2[0]-o1[0])) ? o1[0] :o1[0]+((o2[0]-o1[0])/Math.abs(o2[0]-o1[0]));t[1]=isNaN((o2[1]-o1[1])/Math.abs(o2[1]-o1[1])) ? o1[1] :o1[1]+((o2[1]-o1[1])/Math.abs(o2[1]-o1[1]));return mmap[t[0]][t[1]]==0 ? linelink(t,o2) : false}}else{return false;}}// 上面这个函数是判断任意两个点是否能直线连接（中间的点全为0）var parr=new Array(); pickpoint=function(q1,q2){var j;parr.splice(0);for(j=0;j<mmap[q1[0]].length;j++){parr=mmap[q1[0]][j]==0?parr.concat([[q1[0],j]]):parr; }for(j=0;j<mmap[q2[0]].length;j++){parr=mmap[q2[0]][j]==0?parr.concat([[q2[0],j]]):parr; }for(j=0;j<mmap.length;j++){parr=mmap[j][q1[1]]==0?parr.concat([[j,q1[1]]]):parr; }for(j=0;j<mmap.length;j++){parr=mmap[j][q2[1]]==0?parr.concat([[j,q2[1]]]):parr; }}//上面这个函数是取出两个点的x和y直线方向上的所有空点保存进parr这个数组里面待搜索islink=function(p1,p2){var i,jif(p1==p2){return false;}if(mmap[p1[0]][p1[1]]<>mmap[p2[0]][p2[1]]){return false;}if(linelink(p1,p2)){return true;}else{for(i=0;i<parr.length;i++){for(j=0;j<parr.length;j++){if(linelink(p1,parr[i]) && linelink(p2,parr[j]) && linelink(parr[i],parr[j])) {trace(parr[i]+"->"+parr[j]);return true;}}} }return false;}//上面这个函数是校验两个目标点是否相连，//先判断是否同类点，再判断是否直线相连，最后搜索parr里的每对折点是否使目标点相连pickpoint(p1,p2); //取得parr数组trace(islink(p1,p2)); //测试p1,p2是否相连嘿，运行试试？这个是上面这几个函数的测试源码点击浏览该文件根据这个原理，把图标对照数组，动态建立数组，加上一些效果啊，鼠标检测啊，就成了下面这个这样的基本《连连看》游戏模块啦点击浏览该文件这个是作成游戏后的源码点击浏览该文件>>>> 进入论坛交流<<<<。

FLASH连连看算法分析及源代码

FLASH连连看算法分析及源代码做FLASH连连看有专门的地方，下面咱们就详细分析FLASH连连看的算法。

在做连连看之前，咱们依照折线数的不同分为3种情形：第一种情形：如图，方块1与方块2 在同一水平线上，方块1与方块3在同一垂直线上，这确实是咱们的第一种情形：在实际应历时，咱们在1和2之间或1和3之间实例化一条线段，用hitTestObject 来测试，若是与这条线段相交的图片个数小于等于2，那么这两个图片确实是连通的。

第二种情形：确实是2和3 的关系了，在2和3之间实例化四条线段，两个水平的，两个垂直的，如以下图所示：与A相交的图片数加上与B相交的图片数小于等于2或与C相交的图片数加上与D相交的图片数小于等于2，那么这两个图片确实是连通的。

第三种情形：第三种情形要紧与前两种情形配合利用，若是前两种情形测试不成功，那么直接跳转到第三种情形，若是第三种情形测试仍然不成功，那么这两个图片不连通，也确实是说用户进行了一次错误操作。

第三种情形比较复杂，测试两个图片是不是连通分为两种情形，一种是A线段是水平的(垂直扫描)，另一种是A线段是垂直的(水平扫描)。

线段是水平的，咱们要平均距离垂直扫描并实例化A线段，只有在测试到与A相交的图片数为0时，跳出扫描的循环，而且实例化B线段和C线段，若是与B线段相交的图片数加上与C线段相交的图片数小于等于2，那么两个图片连通。

线段是垂直的，算法与上者相同，只是扫描的方向不同。

好了，下面咱们来亲手做一个简单的连连看。

咱们那个连连看很简单，只要依照下面的操作就能够够了。

假设要运行此例如，请确保在FLASH文件同目录下有一个images文件夹，其中有,,...共40个32*32像素的gif格式的图片。

打开flash cs3，新建一个FLASH文档，在文档类中填写simplellk，在同目录下新建一个AS文件，名为，在其中输入以下代码：package {/**连连看原始模型，供AS3交流所用*/importimportimportpublic class simplellk extends Sprite {private var myllk:llk;private var myllkarr:Array=new Array;private var image:Loader;public function simplellk():void {setlisteners();addllk();}private function setlisteners():void { ("mouseDown",click_stage);("keyUp",keyup);}private function keyup(event):void{if==116){pl();}}private function addllk():void {for (var i:int=0; i<80; i++) {myllk=new llk;image=new Loader;(new URLRequest("images/"+((i%40)+1)+".gif")); (image);=30+(i%10)*40;=30+(i/10)*40;(myllk);addChild(myllk);}pl();itTestPoint(mouseX,mouseY)) {myllkarr[i].selected=!myllkarr[i].selected; myllkarr[i].show_selected();for (var j in myllkarr) {if (j!=i&&myllkarr[j].selected&&j%2)==i%2)) { if (testbylevel(i,j)) {myllkarr[i].removethis();myllkarr[j].removethis();if (i>j) {(i,1);(j,1);} else {(j,1);(i,1);}break;} else {myllkarr[i].selected=false;myllkarr[i].show_selected();myllkarr[j].selected=false;myllkarr[j].show_selected();}} else {if (j!=i) {myllkarr[j].selected=false;myllkarr[j].show_selected();}}}break;}}}private var plarr:Array=new Array;private function pl():void {=30 + () * 10) * 40;myllkarr[aa].y=30 + () * 8) * 40;for (var j:int=0; j < ; j++) {if (myllkarr[aa].x == plarr[j].x && myllkarr[aa].y == plarr[j].y) { cxpl(aa);break;}}for (var i:int=0; i < ; i++) {cxpl(i);(myllkarr[i]);}}private function testbylevel(a:Number,b:Number):Boolean { == myllkarr[b].y || myllkarr[a].x == myllkarr[b].x) {var sprite5:Sprite=new Sprite;+ 16,myllkarr[a].y + 16);+ 16,myllkarr[b].y + 16);addChild(sprite5);js=0;for (var i in myllkarr) {if (myllkarr[i].hitTestObject(sprite5)) {js++;if (js > 2) {break;}}if (js <= 2) {unit=true;} else {unit=testlevelthird(a,b);}} else {var sprite1:Sprite=new Sprite; var sprite2:Sprite=new Sprite; var sprite3:Sprite=new Sprite; var sprite4:Sprite=new Sprite; var test1:Boolean=false;var test2:Boolean=false;+ 10,myllkarr[a].y + 10);+ 10,myllkarr[a].y + 10);+ 10,myllkarr[a].y + 10);+ 10,myllkarr[b].y + 10);+ 10,myllkarr[a].y + 10);+ 10,myllkarr[b].y + 10);+ 10,myllkarr[b].y + 10);+ 10,myllkarr[b].y + 10);addChild(sprite1);addChild(sprite2);addChild(sprite3);addChild(sprite4);js=0;for (var d in myllkarr) {if (myllkarr[d].hitTestObject(sprite1) || myllkarr[d].hitTestObject(sprite2)) { js++;if (js > 2) {break;}}}if (js <= 2) {test1=true;}js=0;for (var e in myllkarr) {if (myllkarr[e].hitTestObject(sprite3) || myllkarr[e].hitTestObject(sprite4)) { js++;if (js > 2) {break;}}}if (js <= 2) {test2=true;}if (test1 || test2) {unit=true;} else {unit=testlevelthird(a,b);}}return unit;}private function testlevelthird(c:Number,d:Number):Boolean { var unit:Boolean=false;var js:int=0;itTestObject(sprite10)) {js++;break;}}if (js == 0) {var sprite11:Sprite=new Sprite;+ 16,6 + 40 * kk);+ 16,myllkarr[c].y + 16);addChild(sprite11);js=0;for (var qq in myllkarr) {if (myllkarr[qq].hitTestObject(sprite11)) { js++;if (js > 1) {break;}}}if (js <= 1) {test3=true;} else {test3=false;}var sprite12:Sprite=new Sprite;+ 16,6 + 40 * kk);+ 16,myllkarr[d].y + 16);addChild(sprite12);js=0;for (var ww in myllkarr) {if (myllkarr[ww].hitTestObject(sprite12)) { js++;if (js > 1) {break;}}}if (js <= 1) {test4=true;} else {test4=false;}if (test3 && test4) {unit=true;break;}}}for (var ii:int=0; ii < 12; ii++) { sprite7=new Sprite ;+ 40 * ii,myllkarr[c].y + 16);+ 40 * ii,myllkarr[d].y + 16); addChild(sprite7);js=0;for (var jj in myllkarr) {if (myllkarr[jj].hitTestObject(sprite7)) { js++;break;}}if (js == 0) {var sprite8:Sprite=new Sprite;+ 40 * ii,myllkarr[c].y + 16);+ 16,myllkarr[c].y + 16);addChild(sprite8);js=0;for (var pp in myllkarr) {if (myllkarr[pp].hitTestObject(sprite8)) { js++;if (js > 1) {break;}}}if (js <= 1) {test1=true;} else {test1=false;}var sprite9:Sprite=new Sprite;+ 40 * ii,myllkarr[d].y + 16);+ 16,myllkarr[d].y + 16);addChild(sprite9);js=0;for (var ll in myllkarr) {if (myllkarr[ll].hitTestObject(sprite9)) { js++;if (js > 1) {break;}}}if (js <= 1) {test2=true;} else {test2=false;}if (test1 && test2) {unit=true;break;}}}return unit;}}}importclass llk extends Sprite { private var mouver:Sprite; private var select:Sprite;public var selected:Boolean=false; public function llk():void {=true;setface();;0, 32, 32);=false;select = new Sprite;.3);0, 32, 32);=false;}private function configlisteners():void { ("mouseOver", over_this); ("mouseOut", out_this);}private function out_this(event):void { if (!selected) {try {removeChild(mouver);} catch (error:Error) {}}}private function over_this(event):void { if (!selected) {addChild(mouver);}}//------------------------------------------------------------------- //public functionspublic function show_selected():void {if (selected) {addChild(select);try {removeChild(mouver);} catch (error:Error) {}} else {try {removeChild(mouver);} catch (error:Error) {}try {removeChild(select);} catch (error:Error) {}}}public function removethis():void { ("mouseOver", over_this);("mouseOut", out_this);(this);}}好了，Ctrl+enter就能够够看到成效了，按F5能够重排。

连连看思路算法及实现

连连看思路算法及实现1. 任务概述连连看是一款益智类图标消除游戏，玩家需要通过消除相同的图标来获得分数。

该游戏的思路算法主要包括图标布局、路径查找和消除逻辑。

本文将详细介绍连连看游戏的思路算法及其实现。

2. 游戏规则在连连看游戏中，通常会给出一个NxM的矩阵，矩阵中填充了各种不同类型的图标。

玩家需要通过点击两个相同的图标，使它们之间的路径最多只有两个直角转弯，从而消除这两个图标。

被消除的图标将被移除，并且上方的图标将下落填充空缺。

玩家的目标是在限定时间内消除尽可能多的图标，获得尽可能高的分数。

3. 思路算法及实现3.1 图标布局图标布局是连连看游戏的一个重要部分。

在游戏开始前，需要生成一个随机的NxM矩阵，并在每个格子中填充一个随机的图标。

为了保证游戏的可玩性，生成的矩阵需要满足以下条件： - 每个图标在矩阵中至少出现两次，确保存在与之相匹配的图标。

- 任意两个相同图标之间的路径不超过两个直角转弯，确保图标可以被消除。

其实现思路如下： 1. 随机生成NxM矩阵，并初始化为空。

2. 随机选择一个图标，将其填充到矩阵中某个随机的空格子。

3. 将该图标在矩阵中的位置存储到一个列表中。

4. 重复2-3步骤，直到每个图标至少在矩阵中出现两次。

5. 遍历矩阵，对于每一个空格子，随机选择一个已填充的图标填充进去，确保每个图标的数量相等。

6. 返回生成的矩阵。

3.2 路径查找路径查找是连连看游戏的关键算法之一。

在玩家点击两个图标后，需要通过路径查找算法判断这两个图标之间是否存在符合条件的路径。

一种常用的路径查找算法是深度优先搜索（DFS）算法。

其实现思路如下： 1. 从起点图标开始，将其标记为已访问。

2. 对于当前图标的每个相邻图标，判断是否满足消除条件（路径最多只有两个直角转弯）。

3. 如果相邻图标满足消除条件且没有被访问过，则递归调用步骤2。

4. 如果找到了与目标图标相匹配的路径，则返回True，否则返回False。

连连看的具体算法

2010年02月21日因为有朋友在站内信中问到连连看的具体算法，所以我就把算法post 出来，这个算法也是参考网上Flash游戏的算法改写的，原来的参考信息已经找不到了，不过非常感谢那些无私的朋友。

改写的连连看算法如下：前置条件：用一二维数组存放Map,-1表示没有图案可以连通，非-1表示不同的图案。

首先是横向检测：Java代码privateboolean horizon(Point a, Point b){if(a.x == b.x && a.y == b.y)//如果点击的是同一个图案，直接返回falsereturnfalse;int x_start = a.y <= b.y ? a.y : b.y;int x_end = a.y <= b.y ? b.y : a.y;for(int x = x_start + 1; x < x_end; x++)//只要一个不是-1，直接返回falseif(map[a.x][x] != -1){ returnfalse; } returntrue; }private boolean horizon(Point a, Point b){if(a.x == b.x && a.y == b.y)//如果点击的是同一个图案，直接返回false return false;int x_start = a.y <= b.y ? a.y : b.y;int x_end = a.y <= b.y ? b.y : a.y;for(int x = x_start + 1; x < x_end; x++)//只要一个不是-1，直接返回falseif(map[a.x][x] != -1){return false;}return true;}其次是纵向检测：Java代码privateboolean vertical(Point a, Point b){if(a.x == b.x && a.y == b.y)returnfalse;int y_start = a.x <= b.x ? a.x : b.x;int y_end = a.x <= b.x ? b.x : a.x;for(int y = y_start + 1; y < y_end; y++)if(map[y][a.y] != -1)returnfalse;returntrue;}private boolean vertical(Point a, Point b){if(a.x == b.x && a.y == b.y)return false;int y_start = a.x <= b.x ? a.x : b.x;int y_end = a.x <= b.x ? b.x : a.x;for(int y = y_start + 1; y < y_end; y++)if(map[y][a.y] != -1)return false;return true;}一个拐角的检测：如果一个拐角能连通的话，则必须存在C、D两点。

小学一年级综合算式算式连连看通过连连看认识加减法运算

小学一年级综合算式算式连连看通过连连看认识加减法运算综合算式连连看是一种以游戏的形式，通过连连看来认识和学习加减法运算的方法。

它能够激发小学一年级学生的兴趣，让他们在玩游戏的过程中不知不觉地学习了解加减法运算。

本文将重点介绍小学一年级综合算式算式连连看的规则和玩法，帮助小学生更好地掌握基本的加减法运算。

一、综合算式连连看规则介绍综合算式连连看是一种以数字和运算符号组成的算式作为游戏元素，通过连接相同的算式来消除的游戏。

在小学一年级中，综合算式连连看多以简单的加减法算式为主，适合小学生认识和练习加减法运算。

游戏中，玩家需要通过连接两个相同的算式来消除它们，以获得得分。

玩家需要注意以下规则：1. 算式连接的路径必须是水平或者垂直的直线路径，且路径上不能有其他的算式阻挡。

2. 算式连接的路径不能有超过两次的转弯，即路径不能有超过两个拐角。

3. 连接的算式必须是相同的，且它们的结果必须是相等的。

4. 连接的算式中可以包括加法和减法运算，但是不可以包括其他的运算符号。

通过以上规则，小学生可以通过综合算式连连看游戏来认识和练习加减法运算，提高他们的计算能力和逻辑思维能力。

二、综合算式连连看的玩法1. 游戏开始后，屏幕上会出现一些算式和运算符号，玩家需要通过观察和思考来找到可以连接的算式。

2. 玩家需要点击两个相同的算式并且路径满足规则的地方，可以进行连接消除。

3. 如果连接的算式路径符合规则且结果相等，这两个算式将会消失，并且玩家可以获得得分。

4. 如果连接的算式路径不符合规则或者结果不相等，这两个算式将不会消失，并且玩家不会获得得分。

通过不断的练习和尝试，小学生可以逐渐掌握综合算式连连看的技巧，提高自己的加减法运算能力。

三、综合算式连连看的学习价值综合算式连连看不仅仅是一种游戏，它还能够帮助小学生学习和掌握加减法运算。

具体有以下几个方面的学习价值：1. 激发兴趣：通过以游戏的形式来学习加减法运算，可以激发小学生的学习兴趣，使他们更加主动地去探索和学习。

连连看的算法

0, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 8, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 9, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 0这是一张连连看的地图，假设标8和9的部分是两张相同的牌。

在数组矩阵中，0表示没有牌，大于1表示有牌。

至于是什么牌，那是随机的了。

不要告诉我，你说的“布局算法”是指怎么把牌刚刚好放上去，那个无所谓什么算法，你只要首先在地图数组中准备好偶数个1，在布牌时保证每种牌是偶数个（不同种类的牌用大于1的数来表示），相应地放入每个1的位置上就可以了。

一、计算地图上这两张牌能不能连通(当然能了，哈哈）。

这是连连看寻路算法的第一步。

先定义一下两张牌能连的充分条件：1.两张牌是同一种。

2.两张牌之间有一条全是0的路可以连通。

3.这一条路不能有两个以上的拐角(corner)满足这三个条件，就可以认为这两张牌是可以连的。

首先，我们依据前两个条件来完成一个基本的寻路算法。

我们的目的是从8到9找出一条可以连通的路来。

那么很明显从8到9的第一步一其有四个方向可以选择，分别是东，南，西，北（e, s, w, n以中国地图方向为标准）四个方向，在第一步中我们首先假设四个方面没有任何优劣，那么我可以任意选择一个方向移动，那就是东面吧。

图二：0, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 8, －8, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 9, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 0我从8向东移动了一步，所以到达了-8的位置，我之所以可以移到-8位置，很明显，是因为-8的位置上原来是一个0，表示没有牌阻挡。

连连看算法详谈

游戏连连看的算法探究及源码实现（1）------ 综述述---转载时请注明原文出处(/wyw1976)及作者邮箱(wyw1976@)“连连看”是一款老少皆宜、百玩不厌的休闲类小游戏。

各种“连连看”也层出不穷、五花八门，例如“果蔬连连看”、“宠物连连看”、“麻将连连看”等。

各种“连连看”大同小异，无非就是界面图片不同，其核心算法应该是类似的。

闲暇时，自己也编了一个“连连看”小游戏，大约有1000行代码，功能如下：（1）纯C、纯字符界面，下面是截图：（2）10种游戏模式：∙普通模式∙左移模式∙右移模式∙上移模式下移模式∙左右分离模式∙上下分离模式∙水平中线聚集模式∙垂直中线聚集模式中心点聚集（3）随机产生游戏初始布局。

（4）随时进行“死锁”监控（5）“死锁”发生时，重新生成游戏残局（6）“路径输出”。

在连通时，输出连通路径。

（7）支持“自动”和“手动”两种模式。

在“自动”模式中，计算机模拟用户完成整个游戏。

这在算法测试时显得尤为重要，因为靠人工来完成算法的测试，十分低效甚至不可能全覆盖，而“自动”模式中，计算机完成一局的时间只要几秒，很容易发现算法中的漏洞。

（8）支持性能统计。

这对于算法优化很重要。

游戏"连连看"的算法探究及源码实现（2）----- 流程图下面是“连连看”的流程图：说明：（1）在"死锁"判定时，只要找到了一对匹配的点，就立即退出并记录该匹配点对，（在需要提示的时候，只要输出该点对即可）。

（2）如果用户的输入点对是连通的，而且与匹配点对中的任何一个是相同的，则需要重新进行“死锁”判定。

（3）在“连通”判定过程中，会生成连通路径。

（4）“更新游戏布局”包括移动相关的点，及消除匹配点。

（5）“初始布局”和“残局”的处理是不同的，这点我们还会详细说明（6）从上述流程图中，可以看出程序主要包含以下几个模块：∙随机生成游戏初始布局∙“死锁”判定∙随机产生游戏残局∙连通判定∙游戏布局更新∙生成联通路径我们将详细描述以上模块的算法及其实现。

《连连看》算法c语言演示（自动连连看）

《连连看》算法c语⾔演⽰（⾃动连连看）（图⽚是游戏的⽰意图，来⾃互联⽹，与本⽂程序⽆关）看题⽬就知道是写给初学者的，没需要的就别看了，⾃⼰都觉得怪⽆聊的。

很多游戏的耐玩性都来⾃精巧的算法，特别是⼈⼯智能的⽔平。

⽐如前⼏天看了著名的Alpha GO的算法，⽤了复杂的⼈⼯智能⽹络。

⽽最简单的，可能就是连连看了，所以很多⽼师留作业，直接就是实现连连看。

连连看游戏的规则⾮常简单：1. 两个图⽚相同。

2. 两个图⽚之间，沿着相邻的格⼦画线，中间不能有障碍物。

3. 画线中间最多允许2个转折。

所以算法主要是这样⼏部分：1. ⽤数据结构描述图板。

很简单，⼀个2维的整数数组，数组的值就是图⽚的标志，相同的数字表⽰相同的图⽚。

有⼀个⼩的重点就是，有些连连看的地图中，允许在边界的两个图⽚，从地图外连线消除。

这种情况⼀般需要建⽴的图板尺⼨，⽐实际显⽰的图板，周边⼤⼀个格⼦，从⽽描述可以连线的空⽩外边界。

本例中只是简单的使⽤完整的图板，不允许利⽤边界外连线。

2. ⽣成图板。

通常⽤随机数产⽣图⽚ID来填充图板就好。

⽐较复杂的游戏，会有多种的布局⽅式，例如两个三⾓形。

这种⼀般要⼿⼯编辑图板模板，在允许填充的区域事先⽤某个特定的整数值来标注，随后的随机数填充只填充允许填充的区域。

本例中只是简单的随机填充。

3. 检查连线中的障碍物。

确定有障碍物的关键在于确定什么样的格⼦是空。

通常定义格⼦的值为0就算空。

要求所有的图⽚ID从1开始顺序编码。

复杂的游戏还会定义负数作为特定的标志，⽐如允许填充区之类的。

4. 检查直接连接：两张图⽚的坐标，必然x轴或者y轴有⼀项相同，表⽰两张图⽚在x轴或者y轴的同⼀条线上才可能出现直接连接。

随后循环检查两者之间是否有障碍物即可确定。

5. 检查⼀折连接：与检查直接连接相反，两个图⽚必须不在⼀条直线上，才可能出现⼀折连接，也就是x/y必须都不相同。

随后以两张图⽚坐标，可以形成⼀个矩阵，矩阵的⼀对对⾓是两张图⽚，假设是A/B两点。

连连看算法及实现原理详解(C++源码)

////////////////////////////////////////////////////////////////////////
void FunctionalModule::m_ColorToNum(HWND hwnd) //把像素转换为数组格式
{
HDC hdc=GetDC(hwnd);
break;
default:
break;
}
}
}
}
}
}
}
}
}
}
////////////////////////////////////////////////////////////////////////
int icolor=0;
COLORREF ccolor1,ccolor2;
for (int n1=0,nx=10;n1<5;n1++,nx-=5)
{
for (int m1=0,my=10;m1<5;m1++,my-=5)
int m_LeftTop(int ax,int ay,int bx,int by); //左上 11
int m_YLeft(int ax,int ay,int bx,int by); //y左 12
int m_LeftBottom(int ax,int ay,int bx,int by); //左下 13
{
ptLineOne.x=0;ptLineOne.y=0;//转折点的两个坐标设为0
ptLineTwo.x=0;ptLineTwo.y=0;
numTotal=(xLast+1)*(yLast+1);//图案总的个数

连连看思路算法及实现

连连看思路算法及实现连连看是一款经典的益智游戏，其玩法简单，规则清晰，深受广大玩家喜爱。

在这个游戏中，我们需要通过消除相同的图案来获得高分。

而要想在游戏中取得好成绩，则需要掌握一定的思路算法和实现方法。

一、思路算法1.寻找相同图案在连连看游戏中，最基本的操作就是寻找相同的图案。

因此，在进行游戏时，我们需要将所有可消除的图案都找出来，并建立起它们之间的关联关系。

2.建立关联关系建立图案之间的关联关系是为了方便后续操作。

我们可以使用二维数组或者链表等数据结构来存储每个图案以及它们之间的连接情况。

对于每一个图案，我们可以将其坐标作为数组下标，并将其与周围相邻的图案进行连接。

3.寻找可消除路径在建立好每个图案之间的连接关系后，我们就可以开始寻找可消除路径了。

通常情况下，可消除路径有两种：直线型和弯曲型。

对于直线型路径，我们只需要判断两个图案之间是否存在直线连接即可；而对于弯曲型路径，则需要考虑路径中是否存在转折点。

4.消除图案当我们找到了可消除路径后，就可以进行图案的消除操作了。

在消除时，我们需要将所有经过的图案都从数据结构中删除，并将得分累加到总分中。

此外，在进行消除操作时，我们还需要考虑一些特殊情况，如图案之间存在障碍物等。

5.判断游戏结束当所有的图案都被消除或者无法再进行消除操作时，游戏就结束了。

在判断游戏是否结束时，我们可以检查当前数据结构中是否还有未被消除的图案。

如果存在未被消除的图案，则说明游戏还未结束；否则，游戏就已经结束了。

二、实现方法1.数据结构在实现连连看游戏时，我们通常使用二维数组或链表等数据结构来存储每个图案以及它们之间的连接关系。

对于二维数组来说，其优点是存储简单、操作方便；而链表则更加灵活，可以动态地添加和删除元素。

2.算法实现在实现连连看游戏时，我们需要编写一些算法来完成相应的功能。

例如，在寻找可消除路径时，我们可以使用广度优先搜索算法（BFS）或深度优先搜索算法（DFS）来遍历所有可能的路径，并找到其中符合要求的路径。

连连看游戏设计思想及程序详细讲解(附源码)

连连看游戏设计思想及程序详细讲解(附源码)１、连连的设计思想1)、准备好相应的大小相同的小图片若干public static final int CELL_SIZEx = 36;public static final int CELL_SIZEy = 40;public static final int CELL_COLS = 34;public static final int CELL_ROWS = 14;public static final int CELL_ZONGS = (CELL_COLS-2)*(CELL_ROWS-2);例如本程序：小图片宽：CELL_SIZEx = 36 高：CELL_SIZEy = 40摆放小图片舞台：横向：34格CELL_COLS= 34纵向：14格CELL_ROWS= 14真正要摆放图片的格数：CELL_ZONGS = (CELL_COLS-2)*(CELL_ROWS-2)即：四面的边格不放图片2)、设定34*14个图片数组，其中除四边外，全部随机存入图片，要保证每种图片各数相同（至少不要差太多），并且是偶数（奇数最后消不掉了）。

3)、在舞台上放上鼠标监听器，当点击任一图片时，做出判断，是否第一次点击（点击标记为0就是第一次点击），如果是第一次点击，就将相关信息记录到第一次内容中，比如：x1,y1,cell1,并将点击标记记为1，再次点击后，判断，点的是否同一图片，如果是，不做处理，如果不是，就认为点击了第二个图片，将相关住处记录到第二次内容中，如：x2,y2,cell2。

然后得用这个方法public boolean delkey()判断两点是否可以连通，如果可以，就消掉图片，不可以就不做处理。

整个连连看原理就是这样，其中有几个难点：１、随机图片，并且保证每种图片数相同，并且为偶数。

２、点击监听３、判断两点是否连通，这个算法是整个连连看的核心，也是最难的。

连连看小游戏

连连看小游戏连连看是一种常见的益智小游戏，目标是消除所有的方块。

游戏中的方块通常会以不同的图案和颜色呈现，玩家需要通过连接相同的方块来消除它们。

规则和玩法：1. 游戏开始时，屏幕上会显示一些方块，玩家需要找到两个相同的方块并用线连接它们。

这条线只能在水平或垂直方向上进行连接，且不能经过其他方块。

2. 当成功连接两个相同的方块时，它们将消失并得分。

玩家需要继续寻找其他相同的方块并连接它们，直到屏幕上的所有方块都被消除。

3. 连接线的路径不能超过两个转弯，也就是说，连接线最多可以有两个直角转弯。

4. 方块之间的连接线不能穿越其他方块，否则连接无效。

5. 对于一些较难的关卡，方块之间可能会有一些障碍物，如墙壁或其他无法消除的方块。

玩家需要巧妙地利用可用的路径和方块来连接相同的方块。

6. 游戏通常有多个关卡，每个关卡的难度逐渐增加。

玩家需要在规定的时间内消除所有的方块，以获得更高的分数和进入下一关。

术语和技巧：1. 连击：如果玩家在短时间内连续消除多个方块，就会触发连击。

连击可以获得额外的分数和奖励，增加游戏乐趣。

2. 剩余方块提示：在一些游戏中，如果玩家无法找到可以连接的方块，可以使用剩余方块提示功能。

该功能会显示剩余的可连接方块，帮助玩家找到更好的策略。

3. 观察和计划：连连看是一种需要观察和计划的游戏。

玩家需要仔细观察方块的位置和图案，并制定最佳的连接策略。

有时候，连接某些方块可能会导致其他方块无法连接，所以需要提前考虑。

4. 快速反应：由于游戏通常有时间限制，玩家需要快速反应和操作，以便在规定时间内消除所有方块。

创造性和想象力：1. 尝试不同的路径：在连接方块时，可以尝试不同的路径和连接方式。

有时候，选择不同的路径可能会带来更多的连击和奖励。

2. 利用障碍物：对于一些有障碍物的关卡，可以利用障碍物之间的空隙和可连接方块来消除它们。

这需要一些创造性的思维和想象力。

3. 观察图案：方块通常有不同的图案和颜色，观察这些图案和颜色的规律可以帮助玩家更快地找到相同的方块并连接它们。

连连看消除算法

连连看消除算法说明：本算法为个人意愿，意在实现功能，并非最优，便于大家理解连连看游戏的实质。

游戏规则：连连看游戏的消除规则玩过了应该挺容易理解，就是两点之间只能用水平或者竖直线段连接，最多不能超过2个拐点。

所以分成了4种情况，1、直接相连2、转一次弯相连3、 Z 型相连4、 U 型相连下面开始提出一种直观的算法：我们来判断两个物体能否消除。

1、我们从一个物体出发，沿十字向外搜集直接相连点，遇到其他物体就终止当前方向搜索。

对两个待判断的物体都进行十字点收集。

2、我们定义一下直接相连：两个点处于水平或者竖直位置，并且中间没有任何其他物体阻挡。

A 、如果是处于消除情况1（直接相连）的情况，那么第二个点应该在第一个的十字搜集点上（直接连）B 、如果是处于消除情况2（转一次弯）的情况，那么物体1十字线上的某点肯定能够和2直接相连C、如果是处于消除情况3或者4，那么物体1十字线上的某点肯定能够和物体2十字线上的某点直接相连D、边界问题我们单独考虑，有的游戏规则中可以边界外走线，有的则不可以，这个对我们算法没有影响。

所以整个程序实现就简单了，伪代码：函数A，判断两点是否可以直接消除函数B，收集指定点十字方向全部直接相连点如果两点可直连则可消除遍历2的直连点如果点1和点2十字中某点可直连则可消除遍历1，2的直连点如果有可直连点则可消除给出一个没完成的python代码供参考：'''Description:link link game auto solver algorithm.Author:winxosDate:2011-05-18'''import randomsize=10m=[[0 for x in range(size)] for y in range(size)]defcreatemap():defcreatepos():return [random.randint(0, size-1), random.randint(0, size-1)]deffillpair(n):a=createpos()while m[a[0]][a[1]]!=0:a=createpos()b=createpos()while m[b[0]][b[1]]!=0 or b==a:b=createpos()m[a[0]][a[1]]=nm[b[0]][b[1]]=nfor i in range(20):fillpair(random.randint(1, 9))passdefisdirectlink(a, b):#a,b is point#return 1 means can link directlyif a[0]==b[0] and a[1]==b[1]: #same point return false return 0if a[0]==b[0]: #Verticalif a[0]==0 or a[0]==size-1: #bound is linkablereturn 1sa=a[1]sb=b[1]ifsb<sa: #field from sa to sb, sa<sbsa=b[1]sb=a[1]for i in range(sa+1, sb-1):if m[a[0]][i]!=0:return 0return 1if a[1]==b[1]: #Horizonif a[1]==0 or a[1]==size-1: #bound is linkablereturn 1sa=a[0]sb=b[0]ifsb<sa: #field from sa to sb, sa<sbsa=b[0]sb=a[0]for i in range(sa+1, sb-1):if m[i][a[1]]!=0:return 0return 1passreturn 0defonelinepoint(a): #return the cross directly linkable points.r=[]i=a[0]-1while m[i][a[1]]==0 and i>0:r.append([i, a[1]])i-=1i=a[0]+1while m[i][a[1]]==0 and i<size:r.append([i, a[1]])i+=1j=a[1]-1while m[a[0]][j]==0 and j>0:r.append([a[0], j])j-=1j=a[1]+1while m[a[0]][j]==0 and j<size:r.append([a[0], j])j+=1return rdefislinkable(a, b): #core function ifisdirectlink(a, b):return 1sa=onelinepoint(a)sb=onelinepoint(b)for x in sa:ifisdirectlink(x, b):return 2for x in sb:ifisdirectlink(a, x):return 2for x in sa:for y in sb:ifisdirectlink(x, y):return 3return 0defprt(n):print("---begin---")for x in n:print(x)createmap()a=[5, 5]b=onelinepoint(a)prt(m)print(b)print("done!")。

连连看算法

如下图所示，连连看总共有四种连法，但算法只需三种。

第一种：
直接连。

只要两图片相邻或两图片一个座标相等，并不相等的座标间图片为空。

第二种：在其中一图片的交叉方同上，找出空位置记录在一数组中，让数组中的各值与另一图片位置进行直接连计算。

交叉连。

第三种：
把两图片交叉方向上的空位置记录在二组数组中，让二组数组进行循环计算直接连。

注：如何判断交叉方向？
if x2>x1, then x1+1就是交叉方向。

Delphi 程序
var p:array of boolean//p记录各图片的数组，有图片为true,没有图片为false.
function zhilian(x1,x2,y1,y2):boolean
var i,k:integer;
begin
result:=true;
if (x1=x2)then begin
k:=y1-y2;
k:=abs(k)/k;// k值变成一个+1或-1
i:=y2;
while y1<>i do begin
i:=i+k;// i 走向交叉方向
if p(x1,i)=true then begin
result:=false;
exit;//
end;
end;
end;
.....
(if (y1=y2)...
end;。

连连看小游戏

连连看小游戏连连看是一款非常受欢迎的益智小游戏，旨在通过消除相同的图案来获得高分。

下面是连连看的玩法和规则。

目标：连连看的目标是通过消除所有的图案来获得最高分数。

规则：1. 游戏板上有许多不同的图案，每个图案都有两个相同的副本。

2. 您需要找到两个相同的图案，并且它们之间的路径没有超过两个弯曲点。

路径可以在水平或垂直方向上连接，但不能穿过其他图案。

3. 一旦找到两个相同的图案，您可以点击它们来消除它们。

消除后，它们之间的路径将被清除，其他图案将会移动填补空缺。

4. 您需要在规定的时间内尽可能多地消除图案，以获得更高的分数。

术语和技巧：1. 连接线：当您点击一个图案时，游戏会显示一条连接线，显示与之匹配的图案的路径。

这有助于您找到可连接的图案。

2. 阻挡：有时候，一些图案会被其他图案所包围，使其无法直接连接。

在这种情况下，您需要先消除阻挡的图案，以便连接两个相同的图案。

3. 时间限制：连连看通常有一个时间限制，您需要在规定的时间内消除尽可能多的图案。

因此，您需要快速思考和观察，以找到最佳的连连看组合。

创造性和想象力：连连看是一个非常灵活的游戏，您可以尝试不同的策略和方法来获得更高的分数。

以下是一些创造性和想象力的建议：1. 观察整个游戏板：在开始游戏之前，花一些时间观察整个游戏板，找出可能的连接路径和潜在的组合。

2. 利用连击：尝试通过连续消除相同的图案来获得连击。

这将为您带来更高的分数，并且还可以清除更多的图案。

3. 考虑未来的移动：在消除图案时，要考虑未来的移动。

有时候，您可能需要暂时放弃一个可连接的图案，以便为将来更好的组合留下空间。

希望这些细节和建议能够帮助您更好地理解连连看，并在游戏中获得更多的乐趣和挑战！。

Python连连看连接算法_322

Python 连连看连接算法_322Python 连连看连接算法[标签:作者][标签:来源][标签:时间]功能：为连连看游戏提供连接算法说明：模块中包含一个Point类，该类是游戏的基本单元“点”，该类包含属性：x,y,value。

其中x,y代表了该点的坐标，value代表该点的特征：0代表没有被填充，1-8代表被填充为游戏图案，9代表被填充为墙壁模块中还包含一个名为points的Point列表，其中保存着整个游戏界面中的每个点使用模块的时候应首先调用createPoints方法，初始化游戏界面中每个点，然后可通过points访问到每个点，继而初始化界面模块中核心的方法是link，通过提供源点和终点，可尝试连接两点，如果可以连接则返回保存路径的path列表，否则返回False"""import random__author__ =";__license__ ="python"class Point:"""Point类Point类是游戏中基本单元：“点” """def __init__(self,x,y,value): self.x = xself.y = yself.value = valueself.directs = Noneself.changed = 0def __createDirect(self,pre,target): """构造点的方向集每个点在连接的过程中都持有一个方向集，这个方向集中保存着该点的前进方向选择的优先级优先级：指向目标点的方向级别最高，在同等级别并且遵循x方向优先于y方向"""self.directs = list()stx = target.x - self.xsty = target.y - self.yif stx >= 0 :self.directs.append("right") self.directs.append("left") else: self.directs.append("left") self.directs.append("right") if sty >= 0 :self.directs.insert(1,"up") self.directs.append("down") else:self.directs.insert(1,"down") self.directs.append("up") if pre == None :returnspx = pre.x - self.xspy = pre.y - self.yif spx == 0 :if spy == 1:self.directs.remove("up") else:self.directs.remove("down") else :if spx == 1:self.directs.remove("right") else:self.directs.remove("left") def forward(self,pre,target): """点的前进动作点的前进即是依次从方向集中取出优先级高的方向，并判断该方向上的下一个点是否被填充如果没有被填充则说明该方向可通，并返回该方向。

连连看游戏算法

• 2 障碍物属性的存放位置障碍物属性尽量不要用方块是否可见等外观因素来确定,外观因素应该由内部变量决定. 因为很可能,某天你要改成消方块只是需要让方块变灰,那么你的内部检验代码要修改,比较麻烦.尽量使用一个数组来存放这些属性.然后外观是另一套代码,这样便于维护.Fra bibliotek谢谢大家！
• 二级检验（只有一个折点）在排除了一级检验的条件后,对两方块的坐标关系没有要求.所以,若横坐标或纵坐标相等,就直接进入三级检验.
在上图中,红线由两线段组成,所以,这个检验相当于两个一级检验结果的"且"运算.可见,一级检验的方法可以用到这里.所以,把一级检验定义为函数,在二级检验中,会方便很多.
注意其中的+1和-1的运算
• 该表达式返回true,那么checkNoBarrier 返回true.否则二级检验结果为false;要进入三级检验
可以发现,所有的折线都有一个特点.两个折点分别跟两方块的横坐标相等或纵坐标相等，因此,我们只需要对折线的中段进行一级检验.至于折点的位置,就让两方块往四个方向走,走到障碍物或者方阵边缘.于是,走过的点都有可能成为折线的折点,在这些点里,看看哪些点对(点的组合)可以作一级检验.
• 注意：：这里很容易忽略的一个情况就是两个方块相邻.这时,y1与y2之间没有点.如果不检验就会错误地跳到二级检验里去.为了避免这种状况的出现,可以在循环之前,定义一临时变量temp=true,然后才到循环语句,遇到障碍物就让temp=false,并且跳出循环.这时,对于相邻的情况来说,因为循环次数为0,所以temp绝对为true. • 综上所述,temp=true,checkNoBarrier就返回true,否则要进入二级检验.

连连看游戏算法实现

连连看算法为了方便，我们假设棋盘大小为 4 * 4，棋子有 4 种。

数字化和布局算法首先，我们知道每种棋子有 4 个，我们可以先按顺序把每种棋子排好，然后再随机取其中两个棋子交换一下，多次交换后，棋子就是乱的了。

参考下面两图，图中用 4 种颜色表示 4 种棋子：(1)初始排布(2)多次随机交换两个棋子后实际上程序内部是不需要认识棋子的图象的，只需要用一个 ID 来表示，界面上画出来的棋子图形是根据 ID 取资源里的图片画的。

比如上图中用 4 种颜色表示 4 种棋子，我们可以定义红色棋子的 ID 为 0，绿色为 1，蓝色为 2，黄色为 3。

另外，如果棋子被消除 ID 可以定义为 -1。

把 ID 放在一个二维矩阵，画到界面上时，根据距阵里元素的位置和值(ID)决定在什么位置画什么颜色棋子。

我见过两种风格的连连看，有一种是和我写的水晶连连看一样，连线可以伸到棋子矩行外面，比如图(2)中的第一行有两个红色棋子，这两个是可以连的；另外一种和 QQGame 里的连连看一样，连线不能伸到棋子矩行外面，也就是说图(2)中的第一行的两个红色棋子是不能连的。

程序内部棋子都是数字，这两种风格的差别在于 ID 距阵的大小，第一种是：(行数 + 2) * (列数 + 2)；第二种是：行数 * 列数，这更简单，所以下面只说第一种。

(行数 + 2) * (列数 + 2) 的距阵，边界上都是 -1（也可以定义为别的，比如 -2），即留了空位给连线通过，而且这些空位不能安排任何棋子，在有些“关”的时候，棋子会移动，也不可以移动到边界的空位上！参考图(3)，其中灰色表示边界空位，灰色边界内部是棋盘：(3)棋盘矩阵化(4)棋子数字化连通算法（1）直连型：太简单不说了。

（2）一折型：其实相当于两个棋子划出一个矩形，这两个棋子是一对对角顶点，另外两个顶点如果可以同时和这两个棋子直连，那就说明可以“一折连通”。

见图(5)两个红色棋子的连通情况，右上角打叉的位置就是折点。

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

0 0 0 0 0 0
三、地图无解提示
因为连接对象的位置是固定的（用重列道具后位置也是固定的），我
们以n个字符串（字符串1维数组）来记录这些位置信息（n==游戏中出现
的物体种类数），一个字符串记录一种，格式型如：
0 0 0 0 1 0 0 0 1 2 0 0 0 * 0 + 0 0
0 0 0 1 2 * 0 2 1 0 0 0 0 2 1 2 0 0
上面三个图，+号是折点，*号就是需要被替换的折点
象的位置信息（对应位置字符串变为－1），比如0208变为-1-1。
四、连接提示功能
根据上面的位置信息数组，按类别依次即时计算该连接对象能否和该
类中其它连接对象相连。比如读取数组的第一个元素，在提取这个字符串
中第一个连接对象的信息，比如1-1-11105-1-11218这个字符串，提取出
右这条路，宣告失败，递归返回到原点，换一个方向从A点向下在开始判断
0 0 0 0 0 0
0 0 1 1 B 0
0 0 0 0 0 0
0 A 0 0 1 0
类别中，有一个星星在游戏中的坐标是[2][8]。
这样，我们就在同一类别中，寻找该类别中现存的任意组合能否连通。
即该类中的一个对象能否和该类别中其它对象连通。
只要找到一个，即有解。如果查找完所有的，那么就提示无解。
当我们消去一对连接对象时，在相应的字符串中删除掉这两个连接对
A点可以与B点连通，路线为
+ *
|
* －－－+
在增加一个障碍
0 0 0 0 0 0
0 0 1 1 B 0
假设A、B两点是同一个图形，来思考一下下面的路线
0 0 0 0 0 0
0 0 1 0 B 0
0 0 0 0 0 0
0 A AA 0 1 0
0 0 0 0 0 0
0 0 0 0 0 0
* 0 0 0 0 0 0 * 0 - 3 ＝ -3
0 * 0 0 0 0 * 0 1 - 3 ＝ -2
0 0 0 0 0 0 0 0
－－－－－－－－－－
情况三：经过两个折点相连（针对企鹅来说，即数字2）
0 + 0 0 0 + 0 0 0 0 0 0
0 2 0 1 0 2 0 2 0 1 0 2
0 0 0 0 0 0 或者 0 + 0 0 0 +
|
| * ------ +
| + ------ *
---------------- x
所以，我们只需判断连点1到折点能否连通，连点2到折点能否连通即可
10208110507151218
第一位1，表示物体的类别（是企鹅？是星星？）
后面16位每4位一组，表示属于这个类别的一个对象的位置
信息，0208 表示数组中的坐标 Array[2][8],即星星这个
0 * 0 1 0 2 （星号为原先的连点）
0 0 0 0 0 0 （转化后的情况三，最左上的折点已经被替换）
现在两个连接对象2之间的情形，已经变为情况二了。
0 0 1 0 B 0
0 0 0 0 0 0
0 A AA AAA 1 0
0 0 0 0 0 0
0 0 0 0 0 0
在AAA处，再次与B点测试连通的时候（按情况二处理），结果是可以，所以
如果我们的算法从向右开始寻找，顺时针方向旋转，那么A点先向右移动1格
到达AA的位置，这时测试AA与B是否能连通（按情况二处理）,结果不能，因
为折点出都有“障碍”（两个1），然后A点在移动，到达AAA处
0 0 0 0 0 0
0 0 0 0 0 0
0 2 0 0 0 + * ------ +
0 + 0 0 0 2 + ------ *
（两条路都可连通）
1 一条直线上两点能否相连是好判断的（一个简单的循环判断即可）
2 对于上面图例的情况二，折点的坐标是固定的，即折点要么是
[连点1的坐标x，连点2的坐标y]要么是[连点1的坐标y，连点2的坐标x]
y
|
0 0 0 0 0 0
0 A 0 0 0
这次，当寻找到AAA位置时，结果为不能连通。在向右，由于有障碍，所以向
由于有1这个障碍，所以需要两个折点才能连通
二、任意两点能否连通
寻路算法是整个游戏的核心算法。网上实现的版本也很多，这里
的方法是我比较容易理解的一个方法^o^ ，还希望大家能提出宝
贵的批评意见和建议，谢谢了。
思路如下：
0 1 2 3 0 1 2 3
2，重列
假设我们在某局游戏中共出现了15种连接对象，每种4个，用1代表星星
2代表企鹅...... ，那么我们仍定义一个字符串444444444444444 一共
11，5这个位置信息，用它来连接12，18看能否连通。
五、道具问题
1，镜子
依然根据位置信息字符串数组，提取每个对象的位置，然后用该连
接对象的坐标x-（游戏宽度-1）取绝对值。
0 0 0 0 0 0 0 0
循环不超过500次
0 0 0 0 0 0
0 0 1 1 B 0
0 0 0 1 1 1
0 A 0 0 0 0
0 0 0 0 0 0
0 AA 0 0 0 0
0 A 0 0 1 0
0 0 0 0 0 0
0 0 0 0 0 0 (AA点与B点符合情况二，可以连通)
目录
一连连看的要求
二任意两点能否连通
三地图无解提示
四连接提示功能
五道具问题
六地图问题
一、连连看的要求
1：要连接的两点上的图形是相同的。
2：两点间存在一条没有“障碍”的并且折点不超过两个的路线。
4 由上可知，寻找这个被替换的折点就成了关键。因为其坐标不固定，所以只
好递归一个一个寻找了。寻找这个点需要做很多的优化（偶也没想到多少）
2 0 0 0 0 + 0 * 0 + 0 0 0 1 0 0 0 0
0 2 0 1 0 2
0 0 0 0 0 0 （情况三）
将和其中一个连点在同一条直线上的折点当作该连点，那么情况三就转化为
了情况二
0 2 0 0 0 +
得知连点1和连点2能否连通。并且由于折点与两个连点分别是在同一条
直线上，所以可以由第一步轻松判断得出结论。
3 将情况三转化为情况二，（这一步是该算法中最影响性能和需要改进的地方）
怎么转化？
0 + 0 0 0 +
情况一：要连接的两点在同一条直线上
0 0 0 0 0 0
0 2 0 0 0 2 * ------ *
0 0 0 0 0 0
情况二：经过一个折点相连（+号代表折点）
那么分析一下可以看到，一般分为三种情况
【图例说明】
假设以一个2维数组来表示一张连连看的地图，数组中
元素值为0的代表游戏界面中的空格子，值大于0的代表游戏
中的各种连接对象（1代表星星、2代表企鹅之类）
路线为
*
|
-----------
|
*
最坏的情况，以QQ 11*19 的大小来计算，共需移动28次，情况2共
0 AA 0 0 0 0
0 AAA 0 0 0 0 (向下仍不能连通)
向左，一样。最后向上
0 0 0 0 0 0
0 0 1 1 B 0