C++笔记-二维棋盘数组使用BFS（宽度优先遍历）

最新推荐文章于 2022-09-23 15:34:43 发布
最新推荐文章于 2022-09-23 15:34:43 发布
阅读量144 收藏
点赞数
文章标签： c++ css 算法
原文链接：https://it1995.blog.csdn.net/article/details/118324634
版权

这里只对一个顶点只能上下左右，不能和左上，左下，右上，右下连起来。

思路步骤：

1.二维棋盘数据转链接表；

2.邻接表直接进行BFS

源码如下：

#include <QDebug>
#include <QVector>
#include <QQueue>
 
#define MAX_COLUMN 6 + 2
#define MAX_ROW 6 + 2
 
//用-1包住，保证处理的统一
int map1[MAX_ROW][MAX_COLUMN] = {
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, 1, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, 1, 1, 0, -1,
    -1, -1, -1, -1, -1, -1, -1, -1
};
 
struct Point{
 
    Point(int vNum, int x, int y) {
 
        this->vNum = vNum;
        this->x = x;
        this->y = y;
    }
 
    int vNum = -1;		//顶点号
    int x;			//x轴
    int y;			//y轴
 
    friend QDebug operator << (QDebug os, Point &test){
 
        os << "(顶点:" << test.vNum << ", x:" << test.x << ", y:" << test.y << ")";
        return os;
    }
};
 
class Graph {
 
public:
    Graph(int map[MAX_ROW][MAX_COLUMN]) {
 
        memcpy(m_map, map, sizeof(m_map));
 
        //不为-1的都是顶点
        int vCount = 0;
 
        for (int i = 0; i < MAX_ROW; i++) {
 
            for (int j = 0; j < MAX_COLUMN; j++) {
 
                if (map[i][j] != -1) {
 
                    Point point(vCount++, i, j);
                    QVector<Point> ve;
                    ve.append(point);
                    m_adj.append(ve);
                }
            }
        }
 
        if (vCount == 0) {
 
            qDebug() << "退出" << endl;
            exit(-1);
        }
 
        this->m_v = vCount;
 
        analysisEdge();
    }
 
    //打印邻接表
    void print() {
 
        for (int i = 0; i < this->m_v; ++i) {
 
            qDebug() << "顶点:" << this->m_adj[i][0].vNum << " x:" << this->m_adj[i][0].x << " y:" << this->m_adj[i][0].y << " 的邻接表!";
            for (int j = 0; j < this->m_adj[i].size(); j++) {
 
                qDebug() << "顶点:" << this->m_adj[i][j].vNum << " x:" << this->m_adj[i][j].x << " y:" << this->m_adj[i][j].y;
            }
 
            qDebug() << "------------------------------------";
        }
    }
 
    void bfs(int startV){
 
        bool visited[this->m_v];
 
        for(int i = 0; i < this->m_v; i++){
 
            visited[i] = false;
        }
 
        Point point = getPointByVertex(startV);
        if(point.vNum == -1){
 
            qDebug() << "顶点错误!";
            exit(0);
        }
 
        QQueue<Point> queue;
        queue.push_back(point);
        visited[startV] = true;
 
        while(!queue.empty()){
 
            Point s = queue.front();
            queue.pop_front();
 
            // start todo something
            qDebug() << s;
 
            // end todo something
 
            for(int i = 0; i < this->m_adj[s.vNum].size(); i++){
 
                int curretV = this->m_adj[s.vNum][i].vNum;
                if(visited[curretV] == false){
 
                    visited[curretV] = true;
                    queue.push_back(this->m_adj[s.vNum][i]);
                }
            }
        }
    }
 
protected:
 
    //通过坐标获取顶点号
    Point getPointByPosXAndPosY(int x, int y) {
 
        for (int i = 0; i < this->m_v; i++) {
 
            if (this->m_adj[i][0].x == x && this->m_adj[i][0].y == y) {
 
                return this->m_adj[i][0];
            }
        }
 
        return Point(-1, -1, -1);
    }
 
    //通过顶点号返回Point
    Point getPointByVertex(int v){
 
        for(int i = 0; i < this->m_v; i++){
 
            if(this->m_adj[i][0].vNum == v){
 
                return this->m_adj[i][0];
            }
        }
 
        return Point(-1, -1, -1);
    }
 
    void analysisEdge() {
 
        //分析下边，这个顶点，如果周围一圈都是非-1的数，说明都可达。
        for (int i = 0; i < this->m_v; i++) {
 
 
            //左上
//            if (m_map[this->m_adj[i][0].x - 1][this->m_adj[i][0].y - 1] != -1) {
 
//                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x - 1, this->m_adj[i][0].y - 1);
//                if (point.vNum != -1) {
 
//                    //顶点是从1开始算，但下标是从0开始
//                    m_adj[this->m_adj[i][0].vNum].push_back(point);
//                }
//            }
 
            //正上
            if (m_map[this->m_adj[i][0].x - 1][this->m_adj[i][0].y] != -1) {
 
                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x - 1, this->m_adj[i][0].y);
                if (point.vNum != -1) {
 
                    //顶点是从1开始算，但下标是从0开始
                    m_adj[this->m_adj[i][0].vNum].push_back(point);
                }
            }
 
            //右上
//            if (m_map[this->m_adj[i][0].x - 1][this->m_adj[i][0].y + 1] != -1) {
 
//                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x - 1, this->m_adj[i][0].y + 1);
//                if (point.vNum != -1) {
 
//                    //顶点是从1开始算，但下标是从0开始
//                    m_adj[this->m_adj[i][0].vNum].push_back(point);
//                }
//            }
 
            //正右
            if (m_map[this->m_adj[i][0].x][this->m_adj[i][0].y + 1] != -1) {
 
                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x, this->m_adj[i][0].y + 1);
                if (point.vNum != -1) {
 
                    //顶点是从1开始算，但下标是从0开始
                    m_adj[this->m_adj[i][0].vNum].push_back(point);
                }
            }
 
            //右下
//            if (m_map[this->m_adj[i][0].x + 1][this->m_adj[i][0].y + 1] != -1) {
 
//                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x + 1, this->m_adj[i][0].y + 1);
//                if (point.vNum != -1) {
 
//                    //顶点是从1开始算，但下标是从0开始
//                    m_adj[this->m_adj[i][0].vNum].push_back(point);
//                }
//            }
 
            //正下
            if (m_map[this->m_adj[i][0].x + 1][this->m_adj[i][0].y] != -1) {
 
                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x + 1, this->m_adj[i][0].y);
                if (point.vNum != -1) {
 
                    //顶点是从1开始算，但下标是从0开始
                    m_adj[this->m_adj[i][0].vNum].push_back(point);
                }
            }
 
            //左下
//            if (m_map[this->m_adj[i][0].x + 1][this->m_adj[i][0].y - 1] != -1) {
 
//                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x + 1, this->m_adj[i][0].y - 1);
//                if (point.vNum != -1) {
 
//                    //顶点是从1开始算，但下标是从0开始
//                    m_adj[this->m_adj[i][0].vNum].push_back(point);
//                }
//            }
 
            //正左
            if (m_map[this->m_adj[i][0].x][this->m_adj[i][0].y - 1] != -1) {
 
                Point point = getPointByPosXAndPosY(this->m_adj[i][0].x, this->m_adj[i][0].y - 1);
                if (point.vNum != -1) {
 
                    //顶点是从1开始算，但下标是从0开始
                    m_adj[this->m_adj[i][0].vNum].push_back(point);
                }
            }
        }
    }
 
 
private:
    int m_v;	//顶点的个数
    int m_map[MAX_ROW][MAX_COLUMN];
    QVector<QVector<Point>> m_adj;
};
 
 
 
int main(int argc, char *argv[]) {
 
    Q_UNUSED(argc)
    Q_UNUSED(argv)
 
    Graph g(map1);
 
    g.print();
    g.bfs(0);
 
    getchar();
    return 0;
}

如下二维棋盘：

int map1[MAX_ROW][MAX_COLUMN] = {
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, 1, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, -1, -1, 0, -1,
    -1, -1, -1, -1, 1, 1, 0, -1,
    -1, -1, -1, -1, -1, -1, -1, -1
};

BFS是这样的（从第1个顶点（下标为0）开始）：

 

bai_Mou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑白棋游戏 （BFS + 位运算初步运用）
一个蒟蒻！
08-13 1467
关于棋盘状态的存储，我们考虑将每个棋盘保存为一个二维数组，在判定新节点的时候需要将新产生的棋盘与前面已有的棋盘逐个比对，但空间和时间消耗都比较大。 标记数组（标记状态是否出现过）的基础类型是bool，每个单元要用一个字节存储，而里面只存储了0和1，实际上浪费了很多空间，有没有办法可以进一步优化呢？.........
C++使用BFS（广度优先）遍历邻接矩阵（源代码）
最新发布
05-31
### C++ 使用 BFS（广度优先）遍历邻接矩阵详解 #### 一、邻接矩阵的概念 **邻接矩阵**是一种非常常见的图数据结构，主要用于表示图中顶点之间的连接关系。它由一个二维数组构成，每个元素代表图中的一条边。具体...
bfs——棋盘游戏
测试
09-23 595
用一个string的01串记录当前的一个局面，每一种情况的16个位置都要尝试去扩展四个方向，遇到合法且没扩展过的就入队，这里获取某一个旗子的坐标使用当前01字符在串中的下标表示。思路：一眼丁真，鉴定为，春春的宽搜。
牛客网-棋盘游戏【bfs】
csyifanZhang的博客
04-24 344
有一个6*6的棋盘，每个棋盘上都有一个数值，现在又一个起始位置和终止位置，请找出一个从起始位置到终止位置代价最小的路径： 1、只能沿上下左右四个方向移动 2、总代价是没走一步的代价之和 3、每步（从a,b到c,d）的代价是c,d上的值与其在a,b上的状态的乘积 4、初始状态为1 每走一步，状态按如下公式变化：（走这步的代价%4）+1。
棋盘游戏（BFS或DFS）
sunshine_lyn的博客
03-12 553
题目描述    有一个6*6的棋盘，每个棋盘上都有一个数值，现在又一个起始位置和终止位置，请找出一个从起始位置到终止位置代价最小的路径：     1、只能沿上下左右四个方向移动     2、总代价是没走一步的代价之和     3、每步（从a,b到c,d）的代价是c,d上的值与其在a,b上的状态的乘积     4、初始状态为1     每走一步，状态按如下公式变化：（走这步的代价%4）+1。输入描述...
HDU 1401 Solitaire(棋盘状态BFS)
code
05-28 2016
HDU 1401 Solitaire(棋盘状态BFS) http://acm.hdu.edu.cn/showproblem.php?pid=1401 题意:对于一个8*8的棋牌,其中有4个棋子,每个棋子可以往上下左右各走一步,但是如果那一步不是空格而是另外一个棋子,那么就越过这个棋子再前进一步.现在给出了初始棋盘状态,和终结棋盘状态,问你在8步内( 分析:本题应该用双向BFS,单BFS容易超
java代码-Java二维数组
07-14
此外，二维数组还可以用于实现各种算法，如深度优先搜索（DFS）和广度优先搜索（BFS）在图论问题中的应用，或者是矩阵运算中的乘法和加法。 在“main.java”文件中，可能会包含有关如何定义、初始化、遍历和操作二...
java 二维数组 随机生成迷宫
10-20
在Java编程中，二维数组常被用来表示矩阵或者游戏中的地图，包括生成迷宫这样的问题。迷宫生成是一种常见的算法挑战，它涉及到随机性、路径探索以及数据结构的使用。本篇文章将深入探讨如何利用二维数组来随机生成...
C++实现图的邻接表存储和广度优先遍历实例分析
09-03
本文主要讲解了如何使用邻接表存储图以及如何实现广度优先遍历（BFS）。邻接表是一种节省空间且适合处理稀疏图（边的数量远小于顶点数量的平方）的数据结构。 首先，我们来理解邻接表的概念。在邻接表中，每个顶点...
C++使用DFS（深度优先）遍历邻接矩阵（源代码）
05-30
### C++ 使用 DFS（深度优先）遍历邻接矩阵 #### 邻接矩阵概述 邻接矩阵是一种常用的数据结构，用于表示图中各顶点之间的连接关系。它通过一个二维数组来存储图的信息，其中行和列代表图中的各个顶点，而数组中的...
提取路径广度优先搜索BFS代码C++
10-19
能够提取最短路径 和最长路径 的 广度优先搜索 BFS （Breadth-first search）代码， 编写语言C++
P3956 棋盘 dfs和bfs
lattice的博客
02-17 435
题目描述 有一个m×m的棋盘，棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在要从棋盘的最左上角走到棋盘的最右下角。 任何一个时刻，你所站在的位置必须是有颜色的（不能是无色的）， 你只能向上、 下、左、 右四个方向前进。当你从一个格子走向另一个格子时，如果两个格子的颜色相同，那你不需要花费金币；如果不同，则你需要花费 1个金币。 另外， 你可以花费 2 个金币施展魔法让下一个无色格子...
残缺的棋盘 （BFS）
a13920760825的博客
09-23 178
在国际象棋里，王是最重要的一个棋子。每一步，王可以往上下左右或者对角线方向移动一步，如下图所示 给定两个格子A(r1c1) B(r2c2)，你的任务是计算出一个王从A到B至少需要走多少步。为了避免题目太简单，我们从棋盘里拿掉了一个格子C(r3c3)（ABC保证互不相同），要求王从A走到B的过程中不能进入格子C。在本题中，各行从上到下编号为1~8，各列从左到右编...
POJ1312 棋盘问题 BFS
Arthur_Holmes的博客
10-29 739
#include<stdio.h> #include<string.h> char map[15][15]; int visit[15]; int n,k; int ans; void dfs(int x,int c) { int i,j; if(c == k) { ans++; return; } for(i = x;i <
图论知识小结3-BFS的数组模拟实现
...
12-06 224
#include &lt;bits/stdc++.h&gt; using namespace std; const int MAX_EDGE = 10000; const int MAX_VERTICES = 100; struct Edge{ int len, v, last; } edge[MAX_EDGE]; int eid; bool vst[MAX_VERTICES]; int la...
bfs和dfs数组实现
亮虎梦
12-19 1111
#include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;queue&gt; using namespace std; int d[205][205]; int visit[205]; int Node[205]; int n; voi...
数组和邻接表的BFS基础用法
qq_36719861的博客
03-03 346
对于BFS的原理在此处就不在讲述，我们直接将具体的实例。首先是结构为数组的情况下BFS的使用：int N = 10000;//随意大小int map[N][N]  //图的结构bool  visit[N];//将其初始化为falsevoid BFS1 (int G[][], int k)  //k为你想要遍历的起点 { int i , j; queue Q;  //建立一个队列cout &lt;&...
bfs+路径记录（数组模拟队列实现）
tick_tock97的博客
05-02 1493
带路径记录的bfs问题，用数组模拟队列，以此来记录数组下标，可以回溯路径
棋盘游戏（BFS、DFS）
weixin_41958296的博客
03-02 443
来源：https://blog.csdn.net/gladyoucame/article/details/8803904#commentBox 个人理解：本质上是一个带权树的最短路径搜索问题，直观反应采用BFS搜索。 自己先暂且记录一下。 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;queue&amp;amp;gt; using namespace std; struct No...
用c++语言写一个关于用数组的广度优先遍历的函数
05-28
好的，这里是一个用数组的C++实现广度优先遍历的函数： ```c++ #include #include using namespace std; // 定义一个图结构 class Graph { private: int** adjMatrix; // 邻接矩阵 int numVertices; // 图中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值