Combination Sum I && II && Validate Binary Search Tree

(1) Combination Sum

利用深度优先遍历BFS[1]:

class Solution {
private:
vector<vector<int>> ret;
vector<int> count;

public:
    void dfs(int dep,int maxDep,vector<int> &candidates,int target) {
        if(target<0)
            return;
            
        if(dep==maxDep)
        {
            if(target==0)
            {
                vector<int> tmp;
                for(int i=0;i<maxDep;i++)
                    if(count[i]!=0)
                    for(int j=0;j<count[i];j++)
                        tmp.push_back(candidates[i]);
                ret.push_back(tmp);
                return;
            }
            return;
        }
        
        for(int i=0;i<=target/candidates[dep];i++)
        {
            count[dep]=i;
            dfs(dep+1,maxDep,candidates,target-i*candidates[dep]);
        }
        
    }
    
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        ret.clear();
        if(candidates.size()==0)
            return ret;
        sort(candidates.begin(),candidates.end());
        count.clear();
        count.resize(candidates.size());
        dfs(0,candidates.size(),candidates,target);
        return ret;
    }
};

注意函数参数中尽量使用引用传值，如果使用值传值，递归调用很多的时候会产生很多临时变量，增加程序开销（临时变量的创建析构），如本例中如果dfs()中的candidates没加&的话，程序运行时间会翻倍。

(2) Combination Sum II

在I的基础上添加一个函数，记录每个字符出现的字数：

class Solution {
private:
vector<vector<int>> ret;
vector<int> count;
vector<int> countMax;
vector<int> candidates;

    void dfs(int dep,int maxDep,vector<int> &candidates,int target) {
        if(target<0)
            return;
            
        if(dep==maxDep)
        {
            if(target==0)
            {
                vector<int> tmp;
                for(int i=0;i<maxDep;i++)
                    if(count[i]!=0)
                    for(int j=0;j<count[i];j++)
                        tmp.push_back(candidates[i]);
                ret.push_back(tmp);
                return;
            }
            return;
        }
        
        for(int i=0;i<=countMax[dep];i++)
        {
            count[dep]=i;
            dfs(dep+1,maxDep,candidates,target-i*candidates[dep]);
        }
        
    }
    
    void preprocess(vector<int> &num) {
        int cur=num[0],count=0;
        
        candidates.push_back(cur);
        for(int i=0;i<num.size();i++)
        {
            if(cur==num[i])
            {
                count++;
            }
            else
            {
                countMax.push_back(count);
                count=1;
                cur=num[i];
                candidates.push_back(cur);
            }
        }
        countMax.push_back(count);
    }
    
public:
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {
        ret.clear();
        if(num.size()==0)
            return ret;
        sort(num.begin(),num.end());
        count.clear();
        count.resize(num.size());
        countMax.clear();
        candidates.clear();
        preprocess(num);
        dfs(0,candidates.size(),candidates,target);
        return ret;
    }
};

(3) Validate Binary Search Tree

用上下限限定来递归[2]:

class Solution {
private:
    bool solve(TreeNode *root, int minval, int maxval)
    {
        if(root==NULL)
            return true;
            
        if(root->val > minval && root->val < maxval)
            return solve(root->left,minval,root->val) && solve(root->right,root->val,maxval);
        else 
            return false;
    }

public:
    bool isValidBST(TreeNode *root) {
        return solve(root,numeric_limits<int>::min(),numeric_limits<int>::max());
    }
};

注：numeric_limits是C++标准程序库中可以调出关于int,float等类型的特性值，如int在系统中支持的最大值或最小值[3]。

参考：

[1] http://blog.youkuaiyun.com/xshalk/article/details/8162857

[2] http://blog.youkuaiyun.com/fightforyourdream/article/details/14444883

[3] http://blog.163.com/wujiaxing009@126/blog/static/7198839920124135147911/