深度搜索处理问题的关键 --- 做leetcode深度搜索类题目小结

最新推荐文章于 2024-04-17 13:52:18 发布

Jared_Yang

最新推荐文章于 2024-04-17 13:52:18 发布

阅读量2.3k

点赞数 5

分类专栏： Leetcode 文章标签：深度优先搜索小结深度优先搜索与回溯法的区别深度优先搜索和递归法的区别

本文链接：https://blog.csdn.net/qq_37007384/article/details/100049368

版权

Leetcode 专栏收录该内容

20 篇文章 2 订阅

订阅专栏

1.深度优先搜索中的关键

深度搜索算法通常用来解决 全排列，不重复组合，分组问题，多条路径，路径的条数等等

对于深度优先搜索，最重要的参数有两个，第一是 深度搜索的次数 step，可以看做需要将待搜索的结果放入到 step 个盒子中，直到放满为止。

第二个是每一次 深度搜索的开始位置start, 主要控制的是每次深度搜索的范围

比如：

对于全排列问题，求[1,2,3]的全排列问题，此时我们可以将问题转化为将 1,2,3按不同的次序放入到三个盒子中，我们需要的是控制深度搜索的次数step，这个次数就是我们深度搜索的结束条件（收敛条件）

对于求子集问题，求[1,2,3]的全部子集（不能重复），与全排列不同，为了求出不重复的子集，我们需要使在1右边的元素永远在1的右边，也就是说，在第二次深度搜索时我们的搜索范围应该是[2,3]，此时我们并不控制深度搜索的次数，而是控制的是深度搜索开始的位置。

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) 
    {
        vector<bool> book(nums.size(),false);
        vector<int> tmp;
        vector<vector<int>> res;
        dfs(nums,0,book,tmp,res);
        return res;
    }
    
private:
    void dfs(vector<int>& nums,int step,vector<bool>&book,vector<int>& tmp,vector<vector<int>>& res)
    {
        if(step == nums.size())
        {
            res.push_back(tmp);
            return;
        }
        for(int i = 0; i < nums.size();i++)
        {
            if(!book[i])
            {
                tmp.push_back(nums[i]);
                book[i] = true;
                dfs(nums,step+1,book,tmp,res);
                tmp.pop_back();
                book[i] = false;
            }
        }
    }
};

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) 
    {
        vector<vector<int>> res;
        vector<int> path;
        dfs(nums, 0, path, res);
        return res;
    }
private:
    void dfs(vector<int>& nums, int start, vector<int>& path, vector<vector<int>>& res)
    {
        res.push_back(path);
        
        for(int i = start; i < nums.size(); i++)//这里用的是start，控制每一次深搜的范围
        {
            path.push_back(nums[i]);
            dfs(nums,i+1,path,res);
            path.pop_back();
        }
    }
    
};

当然，有些情况下，我们即需要控制深搜的次数又需要控制每一次深搜的范围，这种问题典型特征是分配出了要求的盒子数，

而且是组合问题

较简单的：

class Solution {
public:
    vector<vector<int>> combine(int n, int k) 
    {
        vector<vector<int>> res;
        vector<int> path;
        dfs(n, k,1, 0, path, res);
        return res;
    }
    
private:
    void dfs(int n, int k,int start, int step, vector<int>& path, vector<vector<int>>& res)
    {
        if(step == k)
        {
            res.push_back(path);
            return;
        }
        for(int i = start; i <= n; i++)
        {
            path.push_back(i);
            dfs(n,k,i+1,step+1,path,res);
            path.pop_back();
        }
    }
};

较难的：

这一题目中，虽然没有明确说拆分为的盒子数，但是根据IP的特征，应该拆分为4个盒子

同时，这也是一个组合问题（只不过是字符串写在了一起而已），需要控制每次深度搜索的初始位置

class Solution {
public:
    vector<string> restoreIpAddresses(string s) 
    {
        vector<string> res;
        string path;
        if(s.size() > 12)
        {
            return res;
        }
        dfs(s, 0,0,path,res);
        return res;
    }
private:
    void dfs(string s, int start,int step,string path, vector<string>& res)
    {
        if(start == s.size() && step == 4)
        {
            res.push_back(path);
            return;
        }
        for(int i = 1; i <= s.size();i++)
        {
            if(start + i > s.size())
            {
                return;
            }
            string section = s.substr(start,i);
            if(section.size() > 1 && section[0] == '0' || convert(section) > 255)
            {
                return;
            }

            //同时这里用了一个小技巧，因为是字符串，所以不能pop掉后面过来的字符串，所以选择下面这一种方式，来进行回溯
            dfs(s,start+i,step+1,step == 0 ? section : path + "." + section,res);
        }
    }
    int convert(string section)
    {
        int sum = 0;
        for(int i = 0; i < section.size(); i++)
        {
            sum = sum*10 + section[i] - '0';
        }
        return sum;
    }
    
};

对于二维空间的深度搜索，如果起点已经定下，则由此点开始向上下左右扩展即可，如果起点没有定下来，则在主调函数中进行遍历起点，并对每一个起点进行深度优先搜素，同时，如果深度搜索函数有返回值，则对其进行组合处理即可

起点确定下的二维深度搜索：

class Solution {
public:
    int uniquePaths(int m, int n) 
    {
        vector<vector<int>> book(m+1,vector<int>(n+1,0));
        return dfs(m,n,0,0,book);   
    }
    
private:
    int dfs(int m, int n,int i,int j,vector<vector<int>>& book)
    {
        if( i == m-1 && j == n-1)//收敛条件
        {
            return 1;
        }
        if(i >= m || j >= n)
        {
            return 0;
        }
        return getbook(m,n,i+1,j,book) + getbook(m,n,i,j+1,book);        
    }
    
    int getbook(int m,int n,int i,int j,vector<vector<int>>& book)
    {
        if(book[i][j] > 0)
        {
            return book[i][j];
        }
        else
        {
            return book[i][j] = dfs(m,n,i,j,book);
        }
    }
    
};

起点不确定条件下的二维深度搜索：

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) 
    {
        int m = board.size();
        int n = board[0].size();
        vector<vector<bool>> book(m,vector<bool>(n,false));
        
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n;j++)
            {
                if(exist(board,i,j,0,word,book))
                {
                    return true;
                }

            }
        }
        return false;
        
    }
private:
    bool exist(vector<vector<char>>& board,int i,int j,int step,string word,vector<vector<bool>>& book)
    {
        if(step == word.size() )//注意：这个step必须为连续不断的step,不能断
        {
            return true;
        }
        if(i < 0 || j < 0 || i >= board.size() || j >= board[0].size())
        {
            return false;
        }
        if(book[i][j])
        {
            return false;
        }
        if(board[i][j] != word[step])
        {
            return false;
        }

        book[i][j] = true;
        bool res = exist(board,i+1,j,step+1,word,book) || exist(board,i,j+1,step+1,word,book) ||exist(board,i-1,j,step+1,word,book) || exist(board,i,j-1,step+1,word,book);
        book[i][j] = false;
        return res;
    }
};

2.深度优先搜索小结

深度优先搜索适用：

如果是递归数据结构，比如单链表，二叉树，集合，则一定可以用深度搜索，如果是非递归数据结构，如一维数组，二维数组，字符串，图等则概率小一些

明确深搜是求路径本身还是路径条数，前者则用一个数组 path来进行记录存储，后者不用存储路径

终止条件是什么？终止条件只的是不能扩展的末端节点，对于树，则是叶子节点

收敛条件是什么？收敛条件是指找到了一个合法解，很多时候终止条件和收敛条件是合二为一的，但两者代表的含义是不同的

剪枝加速，深度搜索的优点是能在答案生成一半时就进行判断，舍弃不满足要求的答案，减少冗余搜索；利于题设中的各种信息，一旦判断此时的答案不会满足要求，则提前返回，避免冗余搜索

深度搜索代码模板：

void dfs(type *input,type* path,int step(int start),type *result)
{
    if(数据非法) return;
    if(step == input.size() (or start == input.size()))//收敛条件
    {
        将path放入 res中
        return;
    }
    if(可以剪枝) return;
    for(...) //执行所有可能的扩展操作
    {
        执行动作，修改path
        dfs(input,path,step+1(or start+1),res);
        恢复path;        
    }
}

3.深度优先搜索和回溯法的区别

回溯法＝深度搜索＋剪枝

深度搜索准确的来讲，在搜索过程中会保留下来完整的树结构，即使遍历结果不满足答案，也会继续搜素下去，

而回溯法是在深度搜索的过程中进行判断中间结果，如果中间结果不满足条件要求，则进行返回，不再搜索下去，

但是由于现在我们在深度搜索的过程中，或多或少会进行剪枝，所以这样来看两者并没有什么区别

4.深度优先搜索与递归的区别

深搜常常用递归来实现，二者常常同时出现，但是两者并不是同一个东西。

深搜，是一种算法，而递归是一种物理意义上的实现，递归和迭代是对应的。深搜可以用递归来实现，也可以用栈来实现，而递归，一般总用来实现深搜。

可以说，递归一定是深搜，深搜不一定用递归

递归有两种加速策略：一种是剪枝，对中间结果进行判断，提前返回（回溯），一种是加缓存，缓存中间结果，防止重复计算（动态规划），当然动态规划也可以用迭代来实现

还有一个问题：既然递归一定是深搜，那为什么要有两种术语呢？一般而言，在递归味道更浓的地方，一般用递归，比如在单链表，二叉树等递归数据结构上，而在图，数组等数据结构上，递归的比重不大，深搜的味道更浓，所以用深搜，但两者大部分情况下指同一回事。

Jared_Yang

关注

5
点赞
踩
19

收藏

觉得还不错? 一键收藏
1
评论
深度搜索处理问题的关键 --- 做leetcode深度搜索类题目小结

1.深度优先搜索中的关键2.深度优先搜索小结3.深度优先搜索和回溯法的区别4.深度优先搜索与递归的区别1.深度优先搜索中的关键深度搜索算法通常用来解决全排列，不重复组合，分组问题，多条路径，路径的条数等等对于深度优先搜索，最重要的参数有两个，第一是深度搜索的次数 step，可以看做需要将待搜索的结果放入到 step 个盒子中，直到放满为止。第二个是每一...
复制链接

扫一扫