LeetCode刷题（八）——二叉搜索树&回溯法

Day10 2020.07.31&2020.08.01

二叉搜索树定义：

• 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。
• 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。

1.validate-binary-search-tree

判断给出的二叉树是否是一个二叉搜索树（BST）

class Solution {
public:
    //二叉搜索树的中序遍历是有序的,从小到大
    void InOrder(TreeNode* root,vector<int>& inSeq){
        if(root){
            InOrder(root->left,inSeq);
            inSeq.emplace_back(root->val);
            InOrder(root->right,inSeq);
        }
    }
    
    bool isValidBST(TreeNode* root) {
        vector<int> inSeq;
        InOrder(root,inSeq);
        //这个地方一定要判断，不然后面再判断是否有重复元素就会将[0]判定为false
        if(inSeq.size()<2) return true;
        vector<int> temp=inSeq;
        sort(inSeq.begin(),inSeq.end());
        if(temp==inSeq){
            int tag=false;
            for(vector<int>::iterator it=inSeq.begin();it!=inSeq.end();it++){
                if(*it==*(it+1)) tag=true;
            }
            if(tag==false) return true;
            else return false;
        }
        else return false;
    }
};

2.validate-binary-search-tree

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
    //若不在BST中则要返回一个新生成的TreeNode节点
        if(!root) return new TreeNode(val);
        if(val<root->val){
            root->left=insertIntoBST(root->left,val);
        }else{
            root->right=insertIntoBST(root->right,val);
        }
        return root;
    }
};

3.delete-node-in-a-bst

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return root;
        if(root->val>key) root->left=deleteNode(root->left,key);
        else if(root->val<key) root->right=deleteNode(root->right,key);
        else{
            if(!root->left&&!root->right) return nullptr;
            else if(root->left&&!root->right) return root->left;
            else if(!root->left&&root->right) return root->right;
            else{
                //用root的直接后继或直接前驱(中序)代替root
                //root的左子节点连接到右边最左节点即可
                TreeNode* p=root->right;
                while(p->left) p=p->left;
                p->left=root->left;
                return root->right;
            }
        }
        return root;
    }
};

4.balanced-binary-tree

class Solution {
public:
    int Depth(TreeNode* root){
        if(!root) return 0;
        return max(Depth(root->left),Depth(root->right))+1;
        
    }
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        return isBalanced(root->left)&&isBalanced(root->right)&&abs(Depth(root->left)-Depth(root->right))<=1;
    }
};

回溯法定义：

回溯法（backtrack）常用于遍历列表所有子集，是 DFS 深度搜索一种，一般用于全排列，穷尽所有可能，遍历的过程实际上是一个决策树的遍历过程。时间复杂度一般 O(N!)，它不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。
核心就是从选择列表里做一个选择，然后一直递归往下搜索答案，如果遇到路径不通，就返回来撤销这次选择。
回溯算法模板：

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

5.subsets

现在有一个没有重复元素的整数集合S，求S的所有子集
注意：给出的解集中不能出现重复的元素

• 回溯

class Solution {
public:
    void backtrack(vector<int> s,int pos,vector<int> temp,vector<vector<int>>& res){
        //pos即下次添加到集合中的元素位置索引
        auto save=temp;
        res.emplace_back(save);
        for(int i=pos;i<s.size();i++){
            temp.emplace_back(s[i]);
            backtrack(s,i+1,temp,res);
            temp.pop_back();
        }
    }
    
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int>> res;
        vector<int> temp;
        backtrack(S,0,temp,res);
        sort(res.begin(),res.end());
        return res;
    }
};

• 牛客上面还有一个附加要求：你给出的子集中的元素必须按不下降的顺序排列。在遍历之前的原数组要按照元素大小排序；结果数组要按照素组长度排序。

    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int>> res;
        vector<int> temp;
        sort(S.begin(),S.end());
        backtrack(S,0,temp,res);
        //如果要按照题目要求输出的话还需要对结果数组里面的元素按照size从小到大排序
        //自定义比较函数
        sort(res.begin(),res.end(),[](const vector<int>&a,const vector<int>&b)->bool{
            return a.size()==b.size()?a<b:a.size()<b.size();
        });
        return res;
    }

6.subsets-ii

给出一个可能包含重复元素的整数集合S，返回该整数集合的所有子集。
注意：给出的解集中不能包含重复的子集;你给出的子集中的元素要按非递减的顺序排列.
解题思路：首先先将S排序，然后在回溯的时候若为相同元素则跳过。

class Solution {
public:
    void backtrack(vector<int> s,int pos,vector<int> temp,vector<vector<int>>& res){
        auto record=temp;
        res.emplace_back(record);
        for(int i=pos;i<s.size();i++){
            if(i!=pos&&s[i]==s[i-1]) continue;
            temp.emplace_back(s[i]);
            backtrack(s,i+1,temp,res);
            temp.pop_back();
        }
    }
    
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        vector<vector<int>> res;
        vector<int> temp;
        sort(S.begin(),S.end());
        backtrack(S,0,temp,res);
        return res;
    }
};

7.permutations

给出一组数字，返回该组数字的所有排列
例如：[1,2,3]的所有排列如下
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1].
以数字在数组中的位置靠前为优先级，按字典序排列输出。

class Solution {
public:
    void backtrack(vector<int>num,vector<bool> visited,vector<int> temp,vector<vector<int>>& res){
        if(temp.size()==num.size()){//返回条件，当临时结果和集合长度一致，才是全排列
            auto record=temp;
            res.emplace_back(record);
        }
        for(int i=0;i<num.size();i++){
            if(visited[i]) continue;//已经添加过了，直接跳过
            temp.emplace_back(num[i]);
            visited[i]=true;
            backtrack(num,visited,temp,res);
            visited[i]=false;//移除元素
            temp.pop_back();
        }
    }
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int>> res;
        vector<int> temp;
        //因为后面是直接修改visited里面的值，所以要先分配空间和赋值
        vector<bool> visited(num.size(),false);//标记当前元素是否已经添加到结果中
        backtrack(num,visited,temp,res);
        return res;
    }
};

8.permutations-ii

给出一组可能包含重复项的数字，返回该组数字的所有排列
例如；
[1,1,2]的排列如下：
[1,1,2],[1,2,1], [2,1,1].

class Solution {
public:
    void backtrack(vector<int> num,vector<bool> visited,vector<int> temp,vector<vector<int>>& res){
        if(temp.size()==num.size()){
            auto record=temp;
            res.emplace_back(record);
        }
        for(int i=0;i<num.size();i++){
            if(visited[i]) continue;
            //上一个元素与当前元素相同，并且没有访问过就跳过
            if((i!=0&&num[i]==num[i-1])&&!visited[i-1]) continue;
            temp.emplace_back(num[i]);
            visited[i]=true;
            backtrack(num,visited,temp,res);
            visited[i]=false;
            temp.pop_back();
            
        }
    }
    
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int>> res;
        vector<int> temp;
        vector<bool> visited(num.size(),false);
        sort(num.begin(),num.end());
        backtrack(num,visited,temp,res);
        return res;
    }
};

9.combination-sum

给出一组候选数C和一个目标数T，找出候选数中加起来和等于T的所有组合。C中的数字在组合中可以被无限次使用.
注意：
题目中所有的数字（包括目标数T）都是正整数
你给出的组合中的数字 (a 1, a 2, … , a k) 要按非递增排序 (ie, a 1 ≤ a 2 ≤ … ≤ a k).
结解集中不能包含重复的组合
例如：给定的候选数集是[2,3,6,7]，目标数是7
解集是：
[7]
[2, 2, 3]

class Solution {
public:
    void backtrack(int pos,int target,vector<int> candidates,vector<int> temp,vector<vector<int>> &res){
        if(target==0){
            auto record =temp;
            res.emplace_back(record);
        }
        for(int i=pos;i<candidates.size()&&target-candidates[i]>=0;i++){
            temp.emplace_back(candidates[i]);
            //i从当前开始是为了减去重复的
            backtrack(i,target-candidates[i],candidates,temp,res);
            temp.pop_back();
        }
    }
    
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        vector<vector<int>> res;
        vector<int> temp;
        sort(candidates.begin(),candidates.end());
        backtrack(0,target,candidates,temp,res);
        return res;
    }
};

10.letter-combinations-of-a-phone-number

给出一个仅包含数字的字符串，给出所有可能的字母组合。
数字到字母的映射方式如下:(就像电话上数字和字母的映射一样)

Input:Digit string “23”
Output:[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].