深度优先搜索

---

火柴拼正方形

class Solution {
public:
    //4个集合
    int sum[4];
    bool res=false;
    void backtracking(vector<int>&mat,int a,int index){//回溯超时了
        //剪枝
        if(res)return;//已经找到一种拼接方法，直接返回
        if(index==mat.size()){//火柴都遍历完了,每根火柴都只属于一个集合
            if(sum[0]==a&&sum[1]==a&&sum[2]==a&&sum[3]==a){
                res|=true;
            }
            return;
        }
        //mat[index]可以尝试加入每一个集合
        for(int i=0;i<4;++i){
            if(sum[i]+mat[index]<=a){//mat[index]可以加入集合i
                sum[i]+=mat[index];
                backtracking(mat,a,index+1);
                sum[i]-=mat[index];//回溯
            }
        }
        
    }
    bool dfs(vector<int>&mat,int a,int index,int sum1,int sum2,int sum3,int sum4){
        if(index==mat.size()){
            if(sum1==a&&sum2==a&&sum3==a&&sum4==a){
                return true;
            }
            return false;
        }
        if(sum1>a||sum2>a||sum3>a||sum4>a){
            return false;
        }
        return dfs(mat,a,index+1,sum1+mat[index],sum2,sum3,sum4)||
            dfs(mat,a,index+1,sum1,sum2+mat[index],sum3,sum4)||
            dfs(mat,a,index+1,sum1,sum2,sum3+mat[index],sum4)||
            dfs(mat,a,index+1,sum1,sum2,sum3,sum4+mat[index]);
    }
    bool makesquare(vector<int>& matchsticks) {
        int sum=0;
        for(int x:matchsticks){
            sum+=x;
        }
        if(sum%4!=0)return false;
        int a=(sum>>2);//正方形边长
        // backtracking(matchsticks,a,0);//回溯超时 通过了176/183个样例
        //dfs必须加降序才能不超时 s
        sort(matchsticks.begin(),matchsticks.end(),[&](int& a,int& b){return a>b;});
        return dfs(matchsticks,a,0,0,0,0,0);
    }
};

---

从根到叶的二进制数之和

二叉树的所有路径

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void dfs(List<String>list,TreeNode x,String path){
        if(x.left==null&&x.right==null){
            if(path==""){
                list.add(x.val+"");
            }else{
                list.add(path+"->"+x.val);
            }
            return;
        }
        if(x.left!=null)dfs(list,x.left,path==""?(x.val+""):(path+"->"+x.val));
        if(x.right!=null)dfs(list,x.right,path==""?(x.val+""):(path+"->"+x.val));
        
    }
    public List<String> binaryTreePaths(TreeNode root) {
        List<String>list=new ArrayList<>();
        dfs(list,root,"");
        return list;
    }
}

二叉树中第二小的节点

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {

    public int dfs(TreeNode x,int min){
        if(x==null)return -1;
        //x不为null
        if(x.val>min)return x.val;
        //x值等于当前的最小值
        int left=dfs(x.left,min);
        int right=dfs(x.right,min);
        if(left==-1&&right==-1)return -1;
        else if(left==-1||right==-1)return Math.max(left,right);
        return Math.min(left,right);
        
    }
    public int findSecondMinimumValue(TreeNode root) {
        return dfs(root,root.val);
        
    }
}

图像渲染

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        dfs(image,sr,sc,image[sr][sc],newColor);
        return image;
    }
    public void dfs(int[][] image,int row,int col,int value,int newColor){
        //当前位置越界，返回
       if(row<0||row>=image.length||col<0||col>=image[0].length){
            return  ;
        }
        if(image[row][col]==newColor)return;
        if(image[row][col]!=value)return;
        
        //把当前位置上下左右的也涂色
        image[row][col]=newColor;
        dfs(image,row-1,col,value,newColor);
        dfs(image,row+1,col,value,newColor);
        dfs(image,row,col-1,value,newColor);
        dfs(image,row,col+1,value,newColor);

        
    }
}

路径总和

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean dfs(TreeNode x,int sum,int target){//x不可能为null
        if(x.left==null&&x.right==null){//x是叶子节点
            return (sum+x.val)==target;
        }

        //x非叶子节点
        if(x.left!=null&&x.right==null){
            return dfs(x.left,sum+x.val,target);
        }
        if(x.right!=null&&x.left==null){
            return dfs(x.right,sum+x.val,target);
        }
        //x左右子树都不null
        return dfs(x.left,sum+x.val,target)|dfs(x.right,sum+x.val,target);
    }
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null)return false;
        return dfs(root,0,targetSum);
    }
}

二叉树的最小深度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int dfs(TreeNode x){//x不可能为null
        if(x.left==null&&x.right==null){
            return 1;
        }
        if(x.left==null){
            return 1+dfs(x.right);
        }
        if(x.right==null){
            return 1+dfs(x.left);
        }
        return Math.min(dfs(x.left),dfs(x.right))+1;
    }
    public int minDepth(TreeNode root) {
        if(root==null)return 0;
        return dfs(root);
    }
}

相同的树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean dfs(TreeNode p,TreeNode q){
        if(p==null&&q==null){
            return true;
        }
        if(p==null||q==null){
            return false;
        }
        if(p.val!=q.val){
            return false;
        }
        boolean ans;
        ans=dfs(p.left,q.left)&dfs(p.right,q.right);
        return ans;
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        return dfs(p,q);
    }
}

对称二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean dfs(TreeNode x,TreeNode y){
        if(x==null&&y==null)return true;
        if(x==null||y==null)return false;
        if(x.val!=y.val)return false;
        return dfs(x.left,y.right)&&dfs(x.right,y.left);
    }
    public boolean isSymmetric(TreeNode root) {
        return dfs(root,root);
    }
}