C++入门教程（23）深度优先，广度优先（连连看判断是否可以消除）

最近看一个人实现连连看是否可以消除的核心代码，几分钟就写完了，手痒痒自己写了一遍

需求：实现一个函数，输入两个选中的块，判断是否可以消除

连连看规则，两个相同的块可以消除，但是需要满足以下条件，

两个块的连线上不能有其他块

连线的转折次数不能超过2

处在边界的两个块可以绕出地图一个格子去连线

首先是实现连连看的地图，本例使用的是10X10的地图，边界都为0，真实的块只有8X8

int map[MaxLen][MaxHeight] = {0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,1,3,1,3,1,1,0,0,0,0,4,0,1,0,1,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,4,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,5,1,1,0,1,0,0,0,0,0,1,5,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};

0表示可以连线，1是测试的不可连线的值，3，4，5为三对目标块，用来判断是否可以删除

这个程序有几个难点，一个是如何搜索下一个节点，一个是如何避免重复搜索，还有就是如何得到已经找到的路径（需要进行显示线）

搜索下一个节点的实现

由于连线只能是相邻的两个块去连接，所以任意一个目标块为起点，按照四个方向去寻找可搜索的块，直到找到目标块为止。

那么需要定义四个方向，上下左右，

int dir_x[4] = { -1, 1, 0, 0 };
int dir_y[4] = { 0, 0, -1, 1 };

这里用0-3来表示4个方向，每个节点下标和每一个方向对应的dir_x和dir_y进行相加，即可得到相应方向的下一个节点

比如节点 (x1，y1) 遍历4个方向可得到四个新的坐标(x1-1，y1) ，(x1+1，y1) ，(x1，y1-1) ，(x1，y1+1)

避免重复查找

在编码的过程中会发现下面的情况会产生闭环，导致死循环一直查找下去

0,0
0,00,0,0,
0,1,0,
0,0,0,

找了一圈发现又回到第一个0搜索，所以需要实现不能有三次转折，也就是十字路口左转，十字路口左转，十字路口左转，三个红路灯以后，你就能再次看到给你指路的那个大聪明了。

    //当前节点的查找方向int dir;//经过几次转弯int turn;

为了判断是否有转折需要在块中定义每个块的搜索方向，搜索到当前块经过了几次的转折，只要转折超过3次，非法搜索，这样可以防止闭环的产生。

得到已经找到的路径

为了得到已经找到的路径，需要逆向找到前面的节点，所以节点需要定义一个父节点，用来回退找到前面的所有节点。在实现的过程中，没移动一个方向，就制定当前节点为下个节点的parent

块的定义

class Tile
{
public://坐标int x, y;//图片值: 0表示已消除 ,大于0表示图片的idxint value;//当前节点的查找方向int dir;//经过几次转弯int turn;//查找深度int depth;Tile * parent;void init(){dir = -1;turn = -1;depth = -1;parent = NULL;}};

深度优先搜索实现：

//深度优先
bool DFS(Tile tiles[MaxLen][MaxHeight],Tile t1, Tile t2)
{//两个相同节点不可if (t1.x == t2.x && t1.y == t2.y){return false;}//坐标非法不可if (t1.x < 0|| t2.x < 0|| t1.y>= MaxHeight || t2.y>= MaxHeight|| t1.x >= MaxLen || t2.x >= MaxLen){return false;}//深度优先搜索来从一个点找到另一个点Tile * startTile = &t1;startTile->depth = 0;stack<Tile*> sta;sta.push(startTile);vector<Tile * > paths;int result = 0;//开始节点t1一直向目标节点t2移动 能重合则结束while (sta.size() > 0){Tile* lastTile = sta.top();sta.pop();//尝试寻找for (int i = 0; i< 4 ; i++){int x = lastTile->x + dir_x[i];int y = lastTile->y + dir_y[i];if (x<0 || x >= MaxLen || y < 0 || y>= MaxHeight){continue;}Tile *curTile = &tiles[x][y];//上一个节点转了几次弯curTile->turn = lastTile->turn;curTile->dir = i;curTile->depth = lastTile->depth + 1;//如果上一个节点方向改变if (lastTile->dir != curTile->dir){curTile->turn++;}//检查是否回退回去if(dir_x[lastTile->dir] + dir_x[curTile->dir] == 0 &&  dir_y[lastTile->dir] + dir_y[curTile->dir] == 0){//cout << " 不可以回退访问" << endl;continue;}//超过两次转弯不合法if (curTile->turn > 2){continue;}//找到相邻的合法节点if (curTile->value == 0){//cout << " 插入节点x " << curTile->x << " y " << curTile->y << endl;//cout<< " 插入节点转弯次数"<< curTile->turn<< endl;sta.push(curTile);curTile->parent = lastTile;}else if(curTile->value == startTile->value && (curTile->x != startTile->x || curTile->y != startTile->y)){curTile->parent = lastTile;cout << " 找到一条存储路径 搜索深度:" << curTile->depth<< endl;while (curTile->parent != NULL) {cout<<"路径坐标 x = "<< curTile->parent->x<< ",y = "<< curTile->parent->y << endl;curTile = curTile->parent;}result ++;//return true;}}}//return false;return result > 0;
}

由于深度优先搜索第一次查找到的不一定是最优解，所以需要将所有的结果都找到，并从中选取一个最优的结果。本文并没有实现，只是找到了所有的情况，读者可以自行实现，将所有的结果存在vector中，选取最少的那一条即可

广度优先搜索实现：


bool BFS(Tile tiles[MaxLen][MaxHeight],Tile t1, Tile t2)
{//两个相同节点不可if (t1.x == t2.x && t1.y == t2.y){return false;}//坐标非法不可if (t1.x < 0|| t2.x < 0|| t1.y>= MaxHeight || t2.y>= MaxHeight|| t1.x >= MaxLen || t2.x >= MaxLen){return false;}//深度优先搜索来从一个点找到另一个点Tile * startTile = &t1;startTile->depth = 0;queue<Tile*> que;que.push(startTile);vector<Tile * > paths;//开始节点t1一直向目标节点t2移动 能重合则结束while (que.size() > 0){Tile* lastTile = que.front();que.pop();//尝试寻找for (int i = 0; i< 4 ; i++){int x = lastTile->x + dir_x[i];int y = lastTile->y + dir_y[i];if (x<0 || x >= MaxLen || y < 0 || y>= MaxHeight){continue;}Tile *curTile = &tiles[x][y];//上一个节点转了几次弯curTile->turn = lastTile->turn;curTile->dir = i;curTile->depth = lastTile->depth + 1;//如果上一个节点方向改变if (lastTile->dir != curTile->dir){curTile->turn++;}//检查是否回退回去if(dir_x[lastTile->dir] + dir_x[curTile->dir] == 0 &&  dir_y[lastTile->dir] + dir_y[curTile->dir] == 0){//cout << " 不可以回退访问" << endl;continue;}//超过两次转弯不合法if (curTile->turn > 2){continue;}//找到相邻的合法节点if (curTile->value == 0){//cout << " 插入节点x " << curTile->x << " y " << curTile->y << endl;//cout<< " 插入节点转弯次数"<< curTile->turn<< endl;que.push(curTile);curTile->parent = lastTile;}else if(curTile->value == startTile->value && (curTile->x != startTile->x || curTile->y != startTile->y)){curTile->parent = lastTile;cout << " 找到一条存储路径 搜索深度:" << curTile->depth<< endl;while (curTile->parent != NULL) {cout<<"路径坐标 x = "<< curTile->parent->x<< ",y = "<< curTile->parent->y << endl;curTile = curTile->parent;}return true;}}}return false;}

由于广度优先搜索第一个得到的肯定是最优解。所以这个函数找到后就直接返回了。

其实深度优先和广度优先搜索区别只是栈和队列的区别，深度使用的是栈后进先出，广度使用的是队列，先进先出。突然觉得这个栈的实现会不会是为了方便回退到上一个节点而产生的数据结构。

完整代码：

#include <iostream>
#include <vector>
#include <stack>
#include <queue>using namespace std;
#define MaxLen  10
#define MaxHeight  10// 上下左右位移 上,下,左,右
int dir_x[4] = { -1, 1, 0, 0 };
int dir_y[4] = { 0, 0, -1, 1 };//为了方便计算边界可以消除 , 地图数据(最外面一圈都是0) 真实的砖块所在区域为内部8X8的区域
int map[MaxLen][MaxHeight] = {0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,0,1,3,1,3,1,1,0,0,0,0,4,0,1,0,1,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,4,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,5,1,1,0,1,0,0,0,0,0,1,5,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};class Tile
{
public://坐标int x, y;//图片值: 0表示已消除 ,大于0表示图片的idxint value;//当前节点的查找方向int dir;//经过几次转弯int turn;//查找深度int depth;Tile * parent;void init(){dir = -1;turn = -1;depth = -1;parent = NULL;}};//每次查询完需要重置每个块的状态 这里为了方便直接使用Tile节点，也可以自定义新的搜索节点
void initAllTiles(Tile tiles[MaxLen][MaxHeight])
{for (int i = 0; i < MaxLen; i++){for (int j = 0; j < MaxHeight; j++){Tile * t = &tiles[i][j];t->init();}}}
//深度优先
bool DFS(Tile tiles[MaxLen][MaxHeight],Tile t1, Tile t2)
{//两个相同节点不可if (t1.x == t2.x && t1.y == t2.y){return false;}//坐标非法不可if (t1.x < 0|| t2.x < 0|| t1.y>= MaxHeight || t2.y>= MaxHeight|| t1.x >= MaxLen || t2.x >= MaxLen){return false;}//深度优先搜索来从一个点找到另一个点Tile * startTile = &t1;startTile->depth = 0;stack<Tile*> sta;sta.push(startTile);vector<Tile * > paths;int result = 0;//开始节点t1一直向目标节点t2移动 能重合则结束while (sta.size() > 0){Tile* lastTile = sta.top();sta.pop();//尝试寻找for (int i = 0; i< 4 ; i++){int x = lastTile->x + dir_x[i];int y = lastTile->y + dir_y[i];if (x<0 || x >= MaxLen || y < 0 || y>= MaxHeight){continue;}Tile *curTile = &tiles[x][y];//上一个节点转了几次弯curTile->turn = lastTile->turn;curTile->dir = i;curTile->depth = lastTile->depth + 1;//如果上一个节点方向改变if (lastTile->dir != curTile->dir){curTile->turn++;}//检查是否回退回去if(dir_x[lastTile->dir] + dir_x[curTile->dir] == 0 &&  dir_y[lastTile->dir] + dir_y[curTile->dir] == 0){//cout << " 不可以回退访问" << endl;continue;}//超过两次转弯不合法if (curTile->turn > 2){continue;}//找到相邻的合法节点if (curTile->value == 0){//cout << " 插入节点x " << curTile->x << " y " << curTile->y << endl;//cout<< " 插入节点转弯次数"<< curTile->turn<< endl;sta.push(curTile);curTile->parent = lastTile;}else if(curTile->value == startTile->value && (curTile->x != startTile->x || curTile->y != startTile->y)){curTile->parent = lastTile;cout << " 找到一条存储路径 搜索深度:" << curTile->depth<< endl;while (curTile->parent != NULL) {cout<<"路径坐标 x = "<< curTile->parent->x<< ",y = "<< curTile->parent->y << endl;curTile = curTile->parent;}result ++;//return true;}}}//return false;return result > 0;
}bool BFS(Tile tiles[MaxLen][MaxHeight],Tile t1, Tile t2)
{//两个相同节点不可if (t1.x == t2.x && t1.y == t2.y){return false;}//坐标非法不可if (t1.x < 0|| t2.x < 0|| t1.y>= MaxHeight || t2.y>= MaxHeight|| t1.x >= MaxLen || t2.x >= MaxLen){return false;}//深度优先搜索来从一个点找到另一个点Tile * startTile = &t1;startTile->depth = 0;queue<Tile*> que;que.push(startTile);vector<Tile * > paths;//开始节点t1一直向目标节点t2移动 能重合则结束while (que.size() > 0){Tile* lastTile = que.front();que.pop();//尝试寻找for (int i = 0; i< 4 ; i++){int x = lastTile->x + dir_x[i];int y = lastTile->y + dir_y[i];if (x<0 || x >= MaxLen || y < 0 || y>= MaxHeight){continue;}Tile *curTile = &tiles[x][y];//上一个节点转了几次弯curTile->turn = lastTile->turn;curTile->dir = i;curTile->depth = lastTile->depth + 1;//如果上一个节点方向改变if (lastTile->dir != curTile->dir){curTile->turn++;}//检查是否回退回去if(dir_x[lastTile->dir] + dir_x[curTile->dir] == 0 &&  dir_y[lastTile->dir] + dir_y[curTile->dir] == 0){//cout << " 不可以回退访问" << endl;continue;}//超过两次转弯不合法if (curTile->turn > 2){continue;}//找到相邻的合法节点if (curTile->value == 0){//cout << " 插入节点x " << curTile->x << " y " << curTile->y << endl;//cout<< " 插入节点转弯次数"<< curTile->turn<< endl;que.push(curTile);curTile->parent = lastTile;}else if(curTile->value == startTile->value && (curTile->x != startTile->x || curTile->y != startTile->y)){curTile->parent = lastTile;cout << " 找到一条存储路径 搜索深度:" << curTile->depth<< endl;while (curTile->parent != NULL) {cout<<"路径坐标 x = "<< curTile->parent->x<< ",y = "<< curTile->parent->y << endl;curTile = curTile->parent;}return true;}}}return false;}int main()
{//游戏内的所有砖块Tile tiles[MaxLen][MaxHeight];//构建地图for (int i = 0; i< MaxLen ; i++){for (int j = 0; j < MaxHeight; j++){tiles[i][j].init();tiles[i][j].x = i;tiles[i][j].y = j;tiles[i][j].value = map[i][j];}}//深度优先第一个得到的不一定是最优解if (DFS(tiles, tiles[2][2], tiles[2][4])){std::cout << "3可以消除\n";}else{std::cout << "3不可以消除\n";}initAllTiles(tiles);
//    for (int i = 0; i < MaxLen; i++)
//    {
//        for (int j = 0; j < MaxHeight; j++)
//        {
//            Tile * t = &tiles[i][j];
//            t->init();
//        }
//    }//宽度优先可以第一次得到最优解if (BFS(tiles, tiles[2][2], tiles[2][4])){std::cout << "3可以消除\n";}else{std::cout << "3不可以消除\n";}initAllTiles(tiles);if (BFS(tiles, tiles[3][1], tiles[5][1])){std::cout << "4可以消除\n";}else{std::cout << "4不可以消除\n";}initAllTiles(tiles);if (BFS(tiles, tiles[7][1], tiles[8][2])){std::cout << "5可以消除\n";}else{std::cout << "5不可以消除\n";}
}

运行：

 找到一条存储路径 搜索深度:10
路径坐标 x = 3,y = 4
路径坐标 x = 4,y = 4
路径坐标 x = 5,y = 4
路径坐标 x = 6,y = 4
路径坐标 x = 6,y = 3
路径坐标 x = 6,y = 2
路径坐标 x = 5,y = 2
路径坐标 x = 4,y = 2
路径坐标 x = 3,y = 2
路径坐标 x = 2,y = 2找到一条存储路径 搜索深度:6
路径坐标 x = 1,y = 4
路径坐标 x = 0,y = 4
路径坐标 x = 0,y = 3
路径坐标 x = 0,y = 2
路径坐标 x = 1,y = 2
路径坐标 x = 2,y = 2
3可以消除找到一条存储路径 搜索深度:6
路径坐标 x = 1,y = 4
路径坐标 x = 0,y = 4
路径坐标 x = 0,y = 3
路径坐标 x = 0,y = 2
路径坐标 x = 1,y = 2
路径坐标 x = 2,y = 2
3可以消除找到一条存储路径 搜索深度:4
路径坐标 x = 5,y = 0
路径坐标 x = 4,y = 0
路径坐标 x = 3,y = 0
路径坐标 x = 3,y = 1
4可以消除
5不可以消除

本例只是将搜索到的路径打印了出来，可以存在vector数组，用于返回数据

3有两个可以消除的路径

4左侧边界可以消除

5经过边界，由于需要3次转折，所以不能消除。

纯手撸还是需要点时间的，面试如果出这种题，不知道当场能不能直接写出来。继续加油吧

有个疑问，既然广度优先可以直接找到最优解，那么深度优先的优势是什么呢？有存在的必要么？难道是数量级太大的时候，广度优先所查找的范围太大导致内存吃不消么？