DFS深度优先搜索(leetcode题目)

题目链接

• leetcode 494. Target Sum

dp（暴力搜索）

class Solution {
public:
    int ways;
    int findTargetSumWays(vector<int>& nums, int S) {
        ways=0;
        findTargetSum(nums, 0, 0, S);
        return ways;
    }
    void findTargetSum(vector<int>& nums, int i, int sum, int S){
        if(i==nums.size()){
        if(sum==S)
            ways++;
            return;
        }
        findTargetSum(nums, i+1, sum+nums[i], S);
        findTargetSum(nums, i+1, sum-nums[i], S);
    }
};

• Path Sum

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==nullptr)
            return false;
        if(root->left==nullptr && root->right==nullptr){
            if(root->val==sum)
                return true;
            else
                return false;
        }
        bool left = hasPathSum(root->left, sum-root->val);
        bool right = hasPathSum(root->right, sum-root->val);
        return left||right;
    }
};

• 113. Path Sum II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> outer;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<int> v;
        getPathSum(root, v, sum);
        return outer;
    }
    void getPathSum(TreeNode* root, vector<int>& v, int sum){
        if(root==nullptr)
            return;
        
        if(root->left==nullptr && root->right==nullptr && sum==root->val){
            v.push_back(root->val);
            outer.push_back(v);
            v.pop_back();
            return;
        }
        v.push_back(root->val);
        getPathSum(root->left, v, sum-root->val);
        getPathSum(root->right, v, sum-root->val);
        v.pop_back();
        return;
    }
    
};

• 129. Sum Root to Leaf Numbers

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sum=0;
    int sumNumbers(TreeNode* root) {
        getSumNumbers(root, 0);
        return sum;
    }
    void getSumNumbers(TreeNode* root, int number){
        if(root==nullptr)
            return;
        if(root->left==nullptr && root->right==nullptr){
            number = number*10+root->val;
            sum+=number;
            return;
        }
        number = number*10+root->val;
        getSumNumbers(root->left, number);
        getSumNumbers(root->right, number);
        number/=10;
        return;
        
    }

};

• 98. Validate Binary Search Tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return isvalidBST(root, LONG_MIN, LONG_MAX);
    }
    bool isvalidBST(TreeNode* root, long int min, long int max){
        if(root==nullptr)
            return true;
        if(root->val >= max || root->val <= min)
            return false;
        return isvalidBST(root->left, min, root->val) && isvalidBST(root->right, root->val, max);
    }
   
};

• 491. Increasing Subsequences

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        vector<int> v;
        findsubsequences(v, nums, 0);
        return res;
    }
    void findsubsequences(vector<int>& v, vector<int>& nums, int index){
        if(v.size()>1){
            res.push_back(v);
        }
        unordered_set<int> s;
        for(int i=index; i<nums.size(); i++){
            if((v.empty() || nums[i]>=v.back() )&& s.find(nums[i])==s.end()){
                v.push_back(nums[i]);
                findsubsequences(v, nums, i+1);
                v.pop_back();
                s.insert(nums[i]);
            }
            
        }
    }
};