笔试-深搜、广搜算法突破

最新推荐文章于 2024-06-30 17:18:45 发布

NickDeCodes

最新推荐文章于 2024-06-30 17:18:45 发布

阅读量269

点赞数 5

分类专栏：笔试面试突破文章标签：算法深度优先

本文链接：https://blog.csdn.net/NickDeCodes/article/details/139496951

版权

笔试面试突破专栏收录该内容

7 篇文章 0 订阅

订阅专栏

笔试-深搜、广搜算法突破

提到深搜、广搜，大家一般就会说深搜用栈或递归，广搜用队列。
但是其实我认为应该先考虑一下，是搜的对象是什么，是树、还是图
当然无论是图的深搜、还是树的深搜，其基本理念都是一致的

深搜：尽可能沿着每个分支深入到节点的尽头，然后回溯以探索未访问的节点。
广搜：首先访问离起始节点最近的节点，然后逐层向外扩展。

树的搜索

树的深搜

大家都知道树的遍历前、中、后序遍历，可以用栈或者递归，其实这就是树的深搜了

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    // 中
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

树的广搜

其实就是树的层序遍历了，使用队列，一层一层的进行遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

图的搜索

图的深搜

参考代码随想录

可一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯）。

实现方式：

递归方式：利用递归函数实现DFS。
迭代方式：利用栈实现DFS。

深搜三部曲：

确认递归函数，参数

vector<vector<int>> result; // 保存符合条件的所有路径
vector<int> path; // 起点到终点的路径
void dfs (图，目前搜索的节点)

确认终止条件

if (终止条件) {
    存放结果;
    return;
}

处理目前搜索节点出发的路径

for (选择：本节点所连接的其他节点) {
    处理节点;
    dfs(图，选择的节点); // 递归
    回溯，撤销处理结果
}

最终模版

void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本节点所连接的其他节点) {
        处理节点;
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}

图的广搜

参考代码随想录

先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。

实现步骤：

容器：需要一个容器，能保存我们要遍历过的元素就可以，那么用队列，还是用栈，甚至用数组，都是可以的。用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针；如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。
方向数组：创建方向元素，来向四面八方扩展

代码与树的层次遍历类似

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图，也就是一个二维数组
// visited标记访问过的节点，不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
    queue<pair<int, int>> que; // 定义队列
    que.push({x, y}); // 起始节点加入队列
    visited[x][y] = true; // 只要加入队列，立刻标记为访问过的节点
    while(!que.empty()) { // 开始遍历队列里的元素
        pair<int ,int> cur = que.front(); que.pop(); // 从队列取元素
        int curx = cur.first;
        int cury = cur.second; // 当前节点坐标
        for (int i = 0; i < 4; i++) { // 开始想当前节点的四个方向左右上下去遍历
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1]; // 获取周边四个方向的坐标
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 坐标越界了，直接跳过
            if (!visited[nextx][nexty]) { // 如果节点没被访问过
                que.push({nextx, nexty});  // 队列添加该节点为下一轮要遍历的节点
                visited[nextx][nexty] = true; // 只要加入队列立刻标记，避免重复访问
            }
        }
    }

}