1.15 LeetCode总结（基本算法）_DFS之二维平面上的搜索问题

原创 已于 2025-11-08 18:46:36 修改 · 1.3k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #c语言 #算法

于 2020-08-12 23:27:16 首次发布
本文深入探讨了迷宫和岛屿主题的算法问题，包括单词搜索、迷宫基础与进阶、岛屿周长和数量计算等。通过DFS和BFS等技术，解析了各类问题的解决策略和代码实现细节。

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

79. 单词搜索_一刷 on 2025.11.08

思路：DFS遍历下去，都是套路
1）递归终止条件：越界、之前访问过、字符不相等
2）循环退出条件：字符长度已经和输入字符长度相等，返回true
3）逻辑处理，注意回溯的变量处理，赋值后，需要再减回来，visit数组

给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

在这里插入图片描述

DFS

int gVisit[NUM_128][NUM_128] = {
   
   0};
int gDirection[4][2] = {
   
   {
   
   0, -1}, {
   
   0, 1}, {
   
   1, 0}, {
   
   -1, 0}};
int  gBoardSize;
int  *gBoardColSize;
char *gWord;
char **gBoard;
bool DFS(int i, int j, int idx)
{
   
   
    if ((i < 0) || (j < 0) || (i >= gBoardSize) || (j >= *gBoardColSize)) {
   
   
        return false;
    }
    if (gBoard[i][j] != gWord[idx]) {
   
   
        return false;
    }
    if (gVisit[i][j] == 1) {
   
   
        return false;
    }
    if ((idx + 1) == strlen(gWord)) {
   
   
        return true;
    }
    gVisit[i][j] = 1;
    for (int dir = 0; dir < 4; dir++) {
   
   
        int nextX, nextY;
        nextX = i + gDirection[dir][0];
        nextY = j + gDirection[dir][1];
        bool ret = DFS(nextX, nextY, idx + 1);
        if (ret == true) {
   
   
            return true;
        }
    }
    gVisit[i][j] = 0;
    return false;
}
bool exist(char **board, int boardSize, int *boardColSize, char *word)
{
   
   
    gBoard = board;
    gBoardSize = boardSize;
    gBoardColSize = boardColSize;
    gWord = word;
    bool ret = false;
    for (int i = 0; i < NUM_128; i++) {
   
   
        memset(gVisit[i], 0, sizeof(int) * NUM_128);
    }
    for (int i = 0; i < boardSize; i++) {
   
   
        for (int j = 0; j < *boardColSize; j++) {
   
   
            if (board[i][j] == word[0]) {
   
   
                ret = DFS(i, j, 0);
                if (ret == true) {
   
   
                    return true;
                }
            }
        }
    }
    return false;
}
int main()
{
   
   
    char **board = (char **)malloc(sizeof(char *) * 5);
    for (int i = 0; i < 4; i++) {
   
   
        board[i] = (char *)malloc(sizeof(char) * 5);
    }
    strcpy(board[0], "ABCE");
    strcpy(board[1], "SFCS");
    strcpy(board[2], "ADEE");
    int boardSize = 4;
    int boardColSize = 4; 
    char word[7] = "ABCB";
    bool ret = exist(board, boardSize, &boardColSize, word);
    return 0;
}

BFS_部分通过_此题不建议使用

本题使用 BFS 并不适用，因为当前BFS的遍历不会回溯（将 gVisit 变量重新赋值0），会有如下情况导致部分用例Failed；
BFS更偏向无脑横向去遍历

1）访问到“C”时，此时会遍历访问两个“E”进队列，并标记已经访问过（由于目标此时就是匹配字符 “E”）
在这里插入图片描述
2）由于已经进队列并做了访问标记，并不会处理回溯，导致后续无法实现答案这种访问
在这里插入图片描述

int head = 0;
int tail = 0;
int gVisit[NUM_128][NUM_128] = {
   
   0};
int gDirection[4][2] = {
   
   {
   
   0, -1}, {
   
   0, 1}, {
   
   1, 0}, {
   
   -1, 0}};
int  gBoardSize;
int  *gBoardColSize;
char *gWord;
char **gBoard;
typedef struct Node {
   
   
	int x;
	int y;
} Node;
Node queue[NUM_128] = {
   
   0};
bool BFS(int i, int j, int idx)
{
   
   
    int step = 1;
	while (head != tail) {
   
   
		int tmpX = queue[head].x;
		int tmpY = queue[head].y;
		head = (head + 1) % NUM_128;
		if ((step) == strlen(gWord)) {
   
   
			return true;
		}
		for (int dir = 0; dir < 4; dir++) {
   
   
            int nextX, nextY;
            nextX = tmpX + gDirection[dir][0];
            nextY = tmpY + gDirection[dir][1];
            // 有效则进队列
			if ((nextX >= 0) && (nextX < gBoardSize) && (nextY >= 0) && (nextY < *gBoardColSize) && (gVisit[nextX][nextY] == 0) && (gBoard[nextX][nextY] == gWord[step])) {
   
   
				queue[tail].x = nextX;
				queue[tail].y = nextY;
				printf("queue %d %d %c\n", nextX, nextY, gBoard[nextX][nextY]);
				tail = (tail + 1) % NUM_128;
				gVisit[nextX][nextY] = 1;
			}
		}
        step = step + 1;
	}
	return false;
}

bool exist(char **board, int boardSize, int *boardColSize, char *word)
{
   
   
    gBoard = board;
    gBoardSize = boardSize;
    gBoardColSize = boardColSize;
    gWord = word;
    bool ret = false;
    for (int i = 0; i < NUM_128; i++) {
   
   
        memset(gVisit[i], 0, sizeof(int) * NUM_128);
    }
    for (int i = 0; i < boardSize; i++) {
   
   
        for (int j = 0; j < *boardColSize; j++) {
   
   
            if (board[i][j] == word[0]) {
   
   
                queue[tail].x = i;
                queue[tail].y = j;
                gVisit[i][j] = 1;
                tail = (tail + 1) % NUM_128;
                printf("queue %d %d %c\n", i, j, gBoard[i][j]);
                ret = BFS(i, j, 0);
                if (ret == true) {
   
   
                    return true;
                }
            }
        }
    }
    return false;
}
int main()
{
   
   
    char **board = (char **)malloc(sizeof(char *) * 5);
    for (int i = 0; i < 4; i++) {
   
   
        board[i] = (char *)malloc(sizeof(char) * 5);
    }
    strcpy(board[0], "ABCE");
    strcpy(board[1], "SFES");
    strcpy(board[2], "ADEE");
    int boardSize = 4;
    int boardColSize = 4; 
    char word[11] = "ABCESEEEFS";
    bool ret = exist(board, boardSize, &boardColSize, word);
    return 0;
}

迷宫_基础

玩走迷宫的游戏.在一个n*m格子状的迷宫中,有一个入口S和多个出口E(一个迷宫中可能有多个出口,都用E表示).0表示这个格子可以走,1表示这个格子不可以走.小华希望可以最快的走出迷宫.每次只能走一步(在格子可以走的情况下,向上下左右移动一个格子), 他想让你计算最少的步数.
如：
1 0 1
0 S 1
0 0 E
输出2
如果无法到达出口输出 “No way”

思路：DFS遍历下去，都是套路
1）递归终止条件：越界、之前访问过、字符不相等
2）循环退出条件：字符长度已经和输入字符长度相等，返回true
3）逻辑处理，注意回溯的变量处理，赋值后，需要再减回来，visit数组

思路：通过DFS四个方向来做，gStep使用全局变量更新状态，step随递归深度进入到形参里
同时，加了gLen用于剪枝，gLen不为0时，同时超过之前存储的步数直接返回。

#define MAX_N   101
#define MAX_M   101
#define MAX_W   101
#define NUM_BIG 0x7FFFFFFF
char gMaze[MAX_N][MAX_M]  = {
   
   0}; // 二维矩阵，存储矩阵字符串
int  gVisit[MAX_N][MAX_M] = {
   
   0}; // 记录已经访问过的点,用int类型存储
int  gLen[MAX_N][MAX_M]   = {
   
   0}; // 记录访问过的点的步数
int  gResult = 0;
int  gStep = NUM_BIG;
int  gDirection[4][2] = {
   
   {
   
   1,0}, {
   
   -1,0}, {
   
   0,1}, {
   
   0,-1}};

void DFS(int x, int y, int step, int n, int m)
{
   
   
    // 如果已经满足条件，到达出口E，直接返回1，退出
    if (gMaze[x][y] == 'E') {
   
   
        gResult = step;
        gStep = gStep < gResult ? gStep : gResult; // 更新step值
        return ;
    }
    // 1.已经访问过该点，直接返回0，退出
    if (gVisit[x][y] == 1) {
   
   
        return ;
    }
    // 2.坐标越界，直接返回0，退出
    if (x < 0 || y < 0 || x >= n || y >= m) {
   
   
        return ;
    }
    // 3.格子不能走，直接返回0，退出
    if (gMaze[x][y] == '1') {
   
   
        return ;
    }
    // 4.剪枝，通过构造数组记录之前达到每一点需要的步数，如果超过可以步骤直接返回，不用再遍历
    if (gLen[x][y] && gLen[x][y] <= step) {
   
    // gLen不为空且step大于gLen
        return ;
    }
    // 存贮步数点
    gLen[x][y] = step;
    // 标记为已访问点
    gVisit[x][y] = 1;
    // 以下上右左的顺序进行遍历查找
    for (int i = 0; i < 4; i++) {
   
   
        DFS(x + gDirection[i][
最低0.47元/天 解锁文章
入门篇 LeetCode算法之旅启程 - 从零开始的编程进阶之路
一个8年大数据开发工程师的碎碎念
09-03 3154
恭喜你!你已经了解了如何开始你的LeetCode算法之旅。记住,这是一个漫长但充满收获的过程。在这个过程中,你不仅会提升编程技能,还会培养解决问题的思维方式,这将在你的整个职业生涯中受益。保持耐心: 算法学习是一个循序渐进的过程,不要期望一蹴而就。享受过程: 将解题视为一种智力游戏,享受每一次突破的喜悦。与他人交流: 加入学习小组或者参与在线讨论,互相激励和学习。定期回顾: 时常回顾你的学习历程,你会惊讶于自己的进步。保持好奇心: 编程世界日新月异,保持对新知识的渴求。
LeetCode——LCP 31. 变换的迷宫[困难]——分析及代码（Java）
江南土豆的博客
04-10 504
LeetCode——LCP 31. 变换的迷宫[困难]——分析及代码[Java]一、题目二、分析及代码1. 动态规划（1）思路（2）代码（3）结果三、其他 一、题目 某解密游戏中，有一个 N*M 的迷宫，迷宫地形会随时间变化而改变，迷宫出口一直位于 (n-1,m-1) 位置。迷宫变化规律记录于 maze 中，maze[i] 表示 i 时刻迷宫的地形状态，"." 表示可通行空地，"#" 表示陷阱。 地形图初始状态记作 maze[0]，此时小力位于起点 (0,0)。此后每一时刻可选择往上、下、左、右其一方向走一
《算法面试必刷：15 个高频 LeetCode 题（附代码）》
最新发布
2501_93877981的博客
11-02 886
以上15个高频 LeetCode 题覆盖了数组、链表、字符串、树、动态规划、回溯等核心算法主题。掌握这些题能显著提升算法面试成功率。理解每个题的解题思路，避免死记硬背。在 LeetCode 平台实践，测试边界条件。扩展学习类似题目，如“四数之和”或“子集问题”。如果您有具体题目或细节疑问，欢迎随时提问！
OJ笔记 18720 迷宫问题 （最短路径）
Kwan_的博客
04-01 1177
18720 迷宫问题 （最短路径） Description 迷宫是一个n*m的矩阵，玩家需要迷宫入口（坐标1,1）出发，寻找路径走到出口（n,m）。 请判断玩家能否从迷宫中走出，如果能走出迷宫输出，输出最短的路径长度，否则输出-1。 输入格式 第一行两个整数n和m，代表n行m列。(1<=n,m<=10) 下面n行每行m个字符,0代表可以通行，1代表不可以通行。 输出格式 如果能从迷宫走出，输出最短的路径长度，否则输出-1。 输入样例 8 8 00100010 00100010 00001100
[LeetCode] The Maze 迷宫
weixin_33873846的博客
02-09 328
  There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball sto...
Leetcode——迷宫
Yawn
07-24 2356
1. 题目 由空地（用 0 表示）和墙（用 1 表示）组成的迷宫 maze 中有一个球。球可以途经空地向 上、下、左、右 四个方向滚动，且在遇到墙壁前不会停止滚动。当球停下时，可以选择向下一个方向滚动。 给你一个大小为 m x n 的迷宫 maze ，以及球的初始位置 start 和目的地 destination 其中 start = [startrow, startcol] 且 destination = [destinationrow, destinationcol] 。 请你判断球能否在目的地停下：
LeetCode 101_C++_算法_leetcode_leetcode101_leetcode101_源码.zip
09-30
标题 "LeetCode 101_C++_算法_leetcode_leetcode101_leetcode101_源码.zip" 暗示了这是一个与LeetCode第101题相关的C++算法实现代码压缩包。LeetCode是一个知名的在线编程平台，它提供了一系列的编程题目来帮助...
LeetCode 101_C++_算法_leetcode_leetcode101_leetcode101.zip
10-11
标题 "LeetCode 101_C++_算法_leetcode_leetcode101_leetcode101.zip" 提供的信息表明，这是一个关于LeetCode第101题的C++解决方案的压缩包。LeetCode是一个在线平台，它提供了各种编程挑战，帮助开发者提升算法和...
算法_Leetcode_Java刷题_记录点滴_1741872564.zip
03-15
《算法_Leetcode_Java刷题_记录点滴》的内容涵盖了使用Java语言在Leetcode平台上进行算法题目练习的方方面面。该文档不仅包含了对Java语言基础知识点的回顾，还详细记录了作者在解决Leetcode中不同难度题目时的心得...
leetcode-cpp_leetcode_C++_算法_源码分析_剑指offer_
09-30
在LeetCode上，你可以找到各种类型的算法问题，如排序、搜索、图论、动态规划等，这些题目有助于锻炼编程思维和提高代码质量。C++的模板、STL容器（如vector、list、set、map等）、算法库（如sort、find、lower_...
LeetCode
字节跳动 内推找我
06-18 1480
前言前一段时间在刷leetcode的习题，刷了100道题，但是并没有很深刻的感觉(可能是因为自己陷入了为了刷题而刷题的状态中，忘了思考了)。按照自己一贯做事的方案，如果没有很深刻的感觉，那就适时的进行总结。回顾曾走过的路，让自己走的更踏实些。我准备对所刷题目的解答进行汇总。对每一个题目我首先提供我自己的一些解法思路，也有有可能加入一些别人精彩的思路。考虑到工程量的浩大，可能并不会事事巨细。这个仅仅是
LeetCode总结
irlwh的博客
10-18 671
最近完成了www.leetcode.com的online judge中151道算法题目。除各个题目有特殊巧妙的解法以外，大部分题目都是经典的算法或者数据结构，因此做了如下小结，具体的解题思路可以搜索我的博客：LeetCode题解题目 算法 数据结构 注意事项 Clone Graph BFS 哈希表 Word Ladder II BFS 哈希表 Surrounded Regions BFS 矩阵 Wo
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值