【数据结构与算法-搜索（BFS、DFS）系列典例题汇总】

最新推荐文章于 2025-03-04 16:28:51 发布

Wupke

最新推荐文章于 2025-03-04 16:28:51 发布

阅读量1.4k

点赞数 2

分类专栏：剑指offer 数据结构与算法学习文章标签： DFS BFS 数据结构与算法

本文链接：https://blog.youkuaiyun.com/Kefenggewu_/article/details/123540765

版权

剑指offer 同时被 2 个专栏收录

38 篇文章

订阅专栏

数据结构与算法学习

21 篇文章

订阅专栏

本文汇总了五个经典搜索算法问题：岛屿数量（DFS/BFS）、词语阶梯、词语阶梯2、火柴棍摆正方形和收集雨水2。通过实例解析展示了深度优先搜索（DFS）和广度优先搜索（BFS）在解决实际问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【数据结构与算法-搜索（BFS、DFS）系列典例题汇总】

典例1、岛屿数量（medium）

题目描述：
思路：
DFS
BFS
整体的算法思路：
LeetCode提交OJ测试链接:
OJ测试代码实现：

DFS – 深度优先搜索

class Solution {
    // 声明 深度搜索，可以排查标记点的上下左右四个位置
    void DFS(std::vector<std::vector<int> >&mark,
            std::vector<std::vector<char> >&grid,     
            int x,int y){
            mark[x][y]=1;  // 标记已经搜索的位置
        static const int dx[] = {-1,1,0,0} ;// 方向数组（上下左右）
        static const int dy[] = {0,0,-1,1} ;// 方向数组
        for(int i=0;i<4;i++){ // 探索标记位置的上下左右四个点的位置
            int newx = dx[i] + x;  
            int newy = dy[i] + y;
            if(newx<0||newx>=mark.size()||newy<0||newy>=mark[newx].size()){// 数组超过边界时
                continue;
            }
            if(mark[newx][newy]==0 && grid[newx][newy]=='1'){ // 如果当前的位置未探索，且可以达到（在gri范围内）继续深搜
                DFS(mark,grid,newx,newy);
            }

        }
    }

public:
    int numIslands(vector<vector<char>>& grid) {
        int isLand_num = 0;  // 声明变量，岛屿数量
        std::vector<std::vector<int> > mark;
        for(int i=0; i < grid.size(); i++){
            mark.push_back(std::vector<int>());
            for(int j=0;j<grid[i].size();j++){  // 初始化Mark数组都为0
                mark[i].push_back(0);
            }
        }
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[i].size();j++){
                if(mark[i][j]==0 && grid[i][j]=='1'){
                    DFS(mark,grid,i,j);
                    isLand_num ++ ;
                }
            }
        }
        return isLand_num;
    }
};

BFS – 广度优先搜索

class Solution {
    // // 声明 深度搜索，可以排查标记点的上下左右四个位置
    // void DFS(std::vector<std::vector<int> >&mark,
    //         std::vector<std::vector<char> >&grid,     
    //         int x,int y){
    //         mark[x][y]=1;  // 标记已经搜索的位置
    //     static const int dx[] = {-1,1,0,0} ;// 方向数组（上下左右）
    //     static const int dy[] = {0,0,-1,1} ;// 方向数组
    //     for(int i=0;i<4;i++){ // 探索标记位置的上下左右四个点的位置
    //         int newx = dx[i] + x;  
    //         int newy = dy[i] + y;
    //         if(newx<0||newx>=mark.size()||newy<0||newy>=mark[newx].size()){// 数组超过边界时
    //             continue;
    //         }
    //         if(mark[newx][newy]==0 && grid[newx][newy]=='1'){ // 如果当前的位置未探索，且可以达到（在gri范围内）继续深搜
    //             DFS(mark,grid,newx,newy);
    //         }

    //     }
    // }
void BFS(std::vector<std::vector<int> >&mark,
            std::vector<std::vector<char> >&grid,     
            int x,int y){
        static const int dx[] = {-1,1,0,0} ;// 方向数组（上下左右）
        static const int dy[] = {0,0,-1,1} ;// 方向数组
        std::queue<std::pair<int,int> > Q; // 宽度优先搜索队列
        Q.push(std::make_pair(x,y));
        mark[x][y] = 1;
        while(!Q.empty()){
            x = Q.front().first; // 取出队列头部元素
            y = Q.front().second;
            Q.pop(); // 弹出队列的头元素
            for(int i=0;i<4;i++){ 
                int newx = dx[i] + x;  // 拓展四个方向
                int newy = dy[i] + y; 
                if(newx<0||newx>=mark.size()||newy<0||newy>=mark[newx].size()){// 忽略 数组超过边界时的位置
                continue;
            }
            if(mark[newx][newy]==0 && grid[newx][newy]=='1'){ // 如果当前的位置未探索，且可以达到（在gri范围内）继续深搜
                Q.push(std::make_pair(newx,newy));
                mark[newx][newy] = 1;
            }
            }
        }


}




public:
    int numIslands(vector<vector<char>>& grid) {
        int isLand_num = 0;  // 声明变量，岛屿数量
        std::vector<std::vector<int> > mark;
        for(int i=0; i < grid.size(); i++){
            mark.push_back(std::vector<int>());
            for(int j=0;j<grid[i].size();j++){  // 初始化Mark数组都为0
                mark[i].push_back(0);
            }
        }
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[i].size();j++){
                if(mark[i][j]==0 && grid[i][j]=='1'){
                    // DFS(mark,grid,i,j);
                    BFS(mark,grid,i,j);
                    isLand_num ++ ;
                }
            }
        }
        return isLand_num;
    }
};

python3 ---- DFS ( 同化策略 )

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        # DFS 经典搜索算法
        if grid is None or len(grid)==0: # 判断是否为none或者为空           
            return 0
        island_num = 0  # 初始化返回值

        hang = len(grid) # 获取行列
        lie = len(grid[0])
        # 遍历所有的点
        for i in range(0,hang):
            for j in range(0,lie):
                #判断当前元素是否为1，为1则同化为0（进入递归，同时同化了当前位置的四周）
                if grid[i][j] == '1': # 找到岛屿
                    island_num += 1
                    self.DFS(grid,i,j,hang,lie) # 递归
        return island_num


    def DFS(self,grid,i,j,hang,lie):
        # 判断位置是否超出边界 或者 为水域   跳出
        if i<0 or j<0 or i>=hang or j >=lie or grid[i][j]=='0':
            return
        grid[i][j] = '0' # 如果元素等于1同化为 0 （不再访问）
        # 拓展查看当前位置的四周
        self.DFS(grid,i-1,j,hang,lie)   # 上
        self.DFS(grid,i+1,j,hang,lie)   # 下
        self.DFS(grid,i,j-1,hang,lie)   # 左
        self.DFS(grid,i,j+1,hang,lie)   # 右

可本地运行测试的完整代码：

// + 上述的测试代码
int main(){
    std::vector<std::vector<char> >grid;
    char str[10][10] = {"11100","11000","00100","00011"};
    for(int i=0;i<4;i++){
        grid.push_back(std::vector<char>());
        for(int j=0;j<5;j++){
            grid[i].push_back(str[i][j]);
        }
    }
    Solution solve;
    printf("%d\n",solve.numIslands(grid));
    return 0;
}

// 结果为 ：3

典例2、词语阶梯（medium）

题目描述：
思路：
算法流程：

在这里插入图片描述

LeetCode提交OJ测试链接:
OJ测试代码实现：

class Solution {

// 图的表示与构造

bool connect(const std::string &word1,const std::string &word2){
    int cnt = 0; // 记录word1 与 word2 不相等字符的个数
    for(int i=0;i<word1.length();i++){
        if(word1[i]!= word2[i]){
            cnt++;
        }       
    }
    return cnt==1; // 相差一个字符的单词相连
}
// 图相连
void construct_graph(std::string &beginWord,std::vector<std::string> &wordList,std::map<std::string,std::vector<std::string> >&graph){
    wordList.push_back(beginWord);
    for(int i=0;i<wordList.size();i++){
        graph[wordList[i]]=std::vector<std::string>();
    }
    for(int i=0;i<wordList.size();i++){
        for(int j= i+1; j< wordList.size(); j++){
            if(connect(wordList[i],wordList[j])){ //对任意两个单词wordList[i]与wordList[j]，若wordList[i]与wordList]只相差1个字符，则将其相连。
                graph[wordList[i]].push_back(wordList[j]);
                graph[wordList[j]].push_back(wordList[i]);
            }
        }
    }
}
  // 深度优先搜索
int BFS_graph(std::string &beginWord,std::string &endWord,std::map<std::string,std::vector<std::string> >&graph){
    std::queue<std::pair<std::string,int> >Q;//搜索队列<顶点，步数>
    std::set<std::string> visit; // 记录访问过的顶点
    Q.push(std::make_pair(beginWord,1));//添加起始点，起始点步数为1
    visit.insert(beginWord);//标记起始点已经访问
    while(!Q.empty()){ // 只要队列不空，不断的进行搜索
        std::string node=Q.front().first;//取出队列头部节点与步数
        int step=Q.front().second;
        Q.pop();//每搜索完成一个节点，即从队列弹出
        if(node==endWord){ //找到终点，返回步数
            return step;
        }
        const std::vector<std::string>&neighbors=graph[node]; //取node的全部临接点
        for(int i=0; i < neighbors.size(); i++){//若相邻节点还未添加至队列
            if(visit.find(neighbors[i])==visit.end()){
            Q.push(std::make_pair(neighbors[i], step + 1));//到达该节点的步数,为当前步数+1
            visit.insert(neighbors[i]);//标记neighborsi已添加至队列
            }
        }
    }
    return 0;
    }

public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        std::map<std::string,std::vector<std::string> >graph;
        construct_graph(beginWord,wordList,graph);
        return BFS_graph(beginWord,endWord,graph);
    }
};

本地运行测试：

典例3、词语阶梯2（hard）

题目描述：
思路：

在这里插入图片描述

算法思路:
遍历搜索路径

在这里插入图片描述

LeetCode提交OJ测试链接:
OJ测试代码实现：

class Solution {

// 图的表示与构造

bool connect(const std::string &word1,const std::string &word2){
    int cnt = 0; // 记录word1 与 word2 不相等字符的个数
    for(int i=0;i<word1.length();i++){
        if(word1[i]!= word2[i]){
            cnt++;
        }       
    }
    return cnt==1; // 相差一个字符的单词相连
}
// 图相连
void construct_graph(std::string &beginWord,std::vector<std::string> &wordList,std::map<std::string,std::vector<std::string> >&graph){
    int has_begin_word = 0;
    for(int i=0;i<wordList.size(); i++){ //由于wordList中可能有beginWord，直接将beginWord push进入wordList，会出现重复的结果
        if (wordList[i]= beginWord){
            has_begin_word = 1;
        }
        graph[wordList[i]]=std::vector<std::string>();
    }
    for(int i=0;i<wordList.size();i++){
        for(int j= i+1; j< wordList.size(); j++){
            if(connect(wordList[i],wordList[j])){ //对任意两个单词wordList[i]与wordList[j]，若wordList[i]与wordList]只相差1个字符，则将其相连。
                graph[wordList[i]].push_back(wordList[j]);
                graph[wordList[j]].push_back(wordList[i]);
            }
        }
        if (has_begin_word==0 && connect(beginWord,wordList[i])){
            graph[beginWord].push_back(wordList[i]);
        }
    }
}
  // 深度优先搜索
int BFS_graph(std::string &beginWord,std::string &endWord,std::map<std::string,std::vector<std::string> >&graph,
        std::vector<Qitem> &Q, // 使用 vector 实现的队列，可保存所有信息
        std::vector<int> &end_word_pos){ // 终点 end_word 所在队列的位置下标
    std::map<std::string> visit; // <单词，步数>
    int min_step = 0;//到达 endword 的最小步数
    Q.push_back(Qitem(beginWord.c_str(),-1,1)); // 起始单词的前驱为-1
    visit[beginWord] = 1; // 标记起始单词步数为1
    int front=0;  // 队列头指针front ，指向vector表示的队列头
    while(front!=Q.size()){  //front指向Q.size0即vector尾步时，队列为空
        const std:：string &node=Q[front].node;
        int step =Q[front].step；//取队头元素
        if(min_step != 0 && step > min_step){//step>min_step时，代表所有到终点的路径都搜索完成
            break;
        }
        if(node==endWord){ //当搜索到结果时，记录到达终点的最小步数
            min_step=step;
            end_word_pos.push_back(front);
        }
        const std::vector<std:：string>&neighbors=graph[node];
        for(inti=0;i<neighbors.size();i++){  //节点没被访问，或另一条最短路径
            if(visit.find(neighbors[i])== visit.end()|| visit[neighbors[i]==step+1){
                Q.push_back(Qitem(neighbors[i],front，step +1));
                visit[neighbors[i]]= step + 1 ;//标记到达临接点neighbors[i]的最小步数
            }
        }
    front++;
    }
}

public:
    std::vector<std::vector<std::string > > findLadders(std::string beginWord, std::string endWord, std::vector<std::string >& wordList) {
        std::map<std::string,std::vector<std::string> >graph;
        construct_graph(beginWord,wordList,graph);
        std::vector<Qitem> Q; // 使用 vector 实现队列
        std::vector<int> end_word_pos; //endword 在搜索队列的位置
        BFS_graph(beginword，endword，graph，Q，end_word_pos);
        std::vector<std::vector<std::string>>result;//最终结果
        for(int i=0;i< end_word_pos.size(); i++){
            int pos = end_word_pos[i];
            std:：vector<std::string> path;// 从 endWord 到beginWord 将路径上的节点值push进入path 
            while (pos！=-1){
                path.push_back(Q[pos].node);
                pos=Q[pos].parent_pos;
            }             
            result.push_back(std::vector<std::string>());
            for(int j=path.size()-1;j>=0;j--){
                result[i].push_back(path[i]);
            }
        }  
        return result;
    }
};

本地运行测试：

典例4、火柴棍摆正方形（medium）

题目描述：
思路：
LeetCode提交OJ测试链接:
OJ测试代码实现：

class Solution {
public:
    bool makesquare(vector<int>& matchsticks) {
        if(matchsticks.size()<4){ // 数量小于4时返回假
            return false;
        }
        int sum= 0;
        for(int i=0;i<matchsticks.size(); i++){
            sum += matchsticks[i]; //累加求和
        }
        if(sum % 4){
            return false;
        }
        std::sort(matchsticks.rbegin(),matchsticks.rend()); //从大到小排序
        int bucket[4]={0};
        return generate(0,matchsticks, sum / 4,bucket);
    }
private:
    bool generate(int i, std::vector<int>& matchsticks,int target,int bucket[]){
        if (i>=matchsticks.size()){
            return bucket[0]==target && bucket[1]==target && bucket[2]==target && bucket[3]==target;
        }
        for(int j =0; j < 4; j++){//4个桶中分别尝试
            if(bucket[j] + matchsticks[i] > target){
                continue;
            }
            bucket[j] += matchsticks[i]; // 放在j桶中
            if(generate(i+1,matchsticks,target,bucket)){
                return true;
            }
            bucket[j] -= matchsticks[i]; // 回溯
        }
        return false;
    }
};

本地运行测试：

在这里插入图片描述

典例5、收集雨水2（hard）

题目描述：
思路：
算法思路：

在这里插入图片描述

LeetCode提交OJ测试链接:
OJ测试代码实现：

class Solution {
private:
    struct Qitem{
        int x;
        int y;
        int h;
        Qitem(int __x,int __y, int __h):x(__x),y(__y),h(__h){
        }
    };
    struct cmp{
        bool operator()(const Qitem &a, const Qitem &b){
            return a.h > b.h;
        }
    };


public:
    int trapRainWater(vector<vector<int>>& heightMap) {
        priority_queue<Qitem, vector<Qitem>, cmp> Q;
        if(heightMap.size() < 3 || heightMap[0].size() < 3){ // 行数或者列数小于3 必然无法积水
        }
        int row = heightMap.size();// hang
        int column = heightMap[0].size(); // lie 
        vector<vector<int> > mark;
        for (int i=0; i < row; i++){
            mark.push_back(vector<int>());
            for (int j = 0; j < column; j++){
                mark[i].push_back(0);
            }
        }
        for (int i = 0; i < row; i++){
            Q. push(Qitem(i,0, heightMap[i][0])); 
            mark[i][0]=1; 
            Q.push(Qitem(i, column-1, heightMap[i][column-1])); 
            mark[i][column-1]=1; 
        }    
        for (int i=1; i<column-1; i++){
            Q.push(Qitem(0,i, heightMap[0][i])); 
            mark[0][i]=1; 
            Q.push(Qitem(row-1,i, heightMap[row-1][i]));
            mark[row-1][i]=1;
    }
        static const int dx[]={-1,1,0,0};//方向数组
        static const int dy[]={0,0,-1,1};
        int result=0;  //最终积水量
        while(!Q.empty()){
            int x = Q.top().x;//取队列头部信息
            int y=Q.top().y;
            int h=Q.top().h;
            Q.pop();
            for(int i=0; i < 4; i++){ 
                int newx = x + dx[i]; //拓展4个方向
                int newy= y + dy[i];
                if(newx < 0 || newx >= row || newy < 0 || newy >= column || mark[newx][newy]){
                    continue;//当新拓展的点超出边界或已加入队列
                }
                if(h>heightMap[newx][newy]){ //当前点的高度高于拓展点时
                    result += h-heightMap[newx][newy];
                    heightMap[newx][newy]=h;
                }
                Q.push(Qitem(newx,newy,heightMap[newx][newy]));
                mark[newx][newy]=1;
            }
        }
        return result;
    }
};