深度优先搜索(数学哪里出来)

1.搜索的来源

        对于每个问题我们可以建立数学关系式，之后，我们可以套用算法模板，

        但是，有些问题我们无法建立数学关系式，即使有，也木有算法模板可套用，此时，枚举暴力法就派上用场了，第一种是暴力枚举，第二种是暴力搜索即（暴力递归），暴力枚举相信大家并不陌生，接下来我们来看一下还有一种算法，暴力搜索

2.什么是搜索？

        搜索一般建立在一个地图搜索上，先建立起点下标，往上下左右四个方向去递归，一旦发现结果(比如说要找到的节点)，返回结果即可,接下来，我们看一些经典例题:

3.经典例题

        1.leetcode200.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

        这道题本质还是搜索，但是，会复杂一点，我们需要枚举每一个字符，当其为1时，结果+1，去搜索所有与之相邻的点，等于0停止递归，注意设置为传引用

        代码如下:

            

def numIslands(self, grid: [[str]]) -> int:
        def dfs(grid, i, j):
            if not 0 <= i < len(grid) or not 0 <= j < len(grid[0]) or grid[i][j] == '0': return
            grid[i][j] = '0'
            dfs(grid, i + 1, j)
            dfs(grid, i, j + 1)
            dfs(grid, i - 1, j)
            dfs(grid, i, j - 1)
        count = 0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '1':
                    dfs(grid, i, j)
                    count += 1
        return count

     注：本代码来自Krahets(leetcode号)

   2.leetcode98.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

只需中序遍历(左根右)

再判断是否是有序序列

        

class Solution {
public:
    vector<int> vec;
    void dfs(TreeNode* root){
        if(root==nullptr){
            return ;
        }
        dfs(root->left);
        vec.push_back(root->val);
        dfs(root->right);
    }
    bool isValidBST(TreeNode* root) {
        dfs(root);
        int n = vec.size();
        for(int i=0;i<n-1;i++){
            if(vec[i]>=vec[i+1]){
                return false;
            }
        }
        return true;
    }
};

3.leetcode236
二叉树的最近公共祖先

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

代码如下

class Solution {
public:
    TreeNode* ans;
    bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) return false;
        bool lson = dfs(root->left, p, q);
        bool rson = dfs(root->right, p, q);
        if ((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson))) {
            ans = root;
        } 
        return lson || rson || (root->val == p->val || root->val == q->val);
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return ans;
    }
};

                注：本代码来自leetcode官方(leetcode号)

今天到这里了，点个赞再走呗!