DFS-leetcode Combination Sum I/I I

       深度优先搜索(DFS)它是一个搜索算法。第一次接触DFS它应该是一个二进制树的遍历内部，二叉树预订、序和后序实际上属于深度遍历-first。在本质上，深度优先搜索，遍历中则看到了更纯正的深度优先搜索算法。

       通常。我们将回溯法和DFS等同看待。能够用一个等式表示它们的关系：回溯法=DFS+剪枝。所以回溯法是DFS的延伸。其目的在于通过剪枝使得在深度优先搜索过程中假设满足了回溯条件不必找到叶子节点。就截断这一条路径，从而加速DFS。

实际上，即使没有剪枝，DFS在从下层回退到上层的时候也是一个回溯的过程，通常这个时候某些变量的状态。

DFS通经常使用递归的形式实现比較直观。也能够用非递归。但通常须要借组辅助的数据结构（比方栈）来存储搜索路径。

       以下通过leetcode上的两个题目，来展示DFS的应用：

       题一  Combination Sum I，题目大意是这种：有一个正整数集合C，和一个目标数T（T也为正整数）。现从C中选出一些数，使其累加和恰好等于T（C中的每一个数都能够取若干次），求全部不同的取数方案。

       比如：C={2,3,6,7}  T=7

                  res={  [7],

                            [2, 2, 3] }

class Solution {
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        vector<int> tmp;
        sort(candidates.begin(),candidates.end()); //先对C中候选数升序排序。为后面的剪枝做准备
        sou=candidates;
        dfs(tmp,target,0);
        return res;
    }
private:
    vector<vector<int> > res;  //保存最后结果
    vector<int> sou;  
    int sum(vector<int> tmp){ //计算累加和
        int r=0;
        for(int i=0;i!=tmp.size();++i)
            r+=tmp[i];
        return r;
    }
    void dfs(vector<int> &tmp,int tag,int l){
        if(l==sou.size()) //搜索到叶节点
            return ;
        int tot=sum(tmp);
        if(tot==tag){
            res.push_back(tmp);
            return ;
        }else if(tot>tag)  //剪枝
            return ;
        else{
            for(int i=l;i!=sou.size();++i){ //由于C中每一个数能够选多次，所以i从l開始，而不是l+1
                tmp.push_back(sou[i]);
                dfs(tmp,tag,i);
                tmp.pop_back(); //回溯，恢复tmp状态
            }
        }
    }
};

       题二  Combination Sum II，与题一得差别是集合C中的每一个数最多仅仅能取一次，只是C中能够有反复的数。

       比如：C={10,1,2,7,6,1,5}  T=8

                  res={ [1, 7]
                           [1, 2, 5]
                           [2, 6]
                           [1, 1, 6] }

       题二能够採用与题一类似的方法。可是因为题二中的每一个数仅仅能取一次，所以dfs函数中的for循环，i应从l+1開始，表示取下一个数。但这样带来的问题是，结果中会出现反复的取数方案。拿上面的样例来分析：C中有两个1能够选，那第一个1和7是一种可选方案（1+7=8）。第二个1和7也是一种可选方案，依照上述算法。[1,7]会在结果中出现两次。当然能够对最后结果去重（假设用C++的话，sort->unique->erase能够实现）。

不幸的是，这样的解法会超时。解决超时的方案是不要将反复的方案增加到结果集中。也就避免了去重的工作。AC代码例如以下：

class Solution {
public:
    vector<vector<int> > combinationSum2(vector<int> &candidates, int target) {
        vector<int> tmp;
        for(int i=0;i!=candidates.size();++i){  //mm是一个map，key为C中可取的数，value为该数有多少个
            mm[candidates[i]]++;
        }
        for(map<int,int>::iterator it=mm.begin();it!=mm.end();++it){
            for(int i=0;i<it->second;++i){
                tmp.push_back(it->first);
                dfs(tmp,target,it);
            }
            for(int i=0;i<it->second;++i){  //回溯。恢复tmp状态
                tmp.pop_back();
            }
        }
        return res;
    }
private:
    vector<vector<int> > res; //保存最后结果
    map<int ,int > mm;

    int sum(vector<int> tmp){ //计算累加和
        int r=0;
        for(int i=0;i!=tmp.size();++i)
            r+=tmp[i];
        return r;
    }
    void dfs(vector<int> &tmp,int tag,map<int,int>::iterator it){
        if(it==mm.end())  //搜索到叶节点
            return ;
        int tot=sum(tmp);
        if(tot==tag){
            res.push_back(tmp);
            return ;
        }else if(tot>tag)  //剪枝
            return ;
        else{
            for(++it;it!=mm.end();++it){
                for(int i=0;i<it->second;++i){
                    tmp.push_back(it->first);
                    dfs(tmp,tag,it);
                }
                for(int i=0;i<it->second;++i){  //回溯，恢复tmp状态
                    tmp.pop_back();
                }
            }
        }
    }
};

关键代码：

for(++it;it!=mm.end();++it){
    for(int i=0;i<it->second;++i){
        tmp.push_back(it->first);
        dfs(tmp,tag,it);
    }
    for(int i=0;i<it->second;++i){  //回溯，恢复tmp状态
        tmp.pop_back();
    }
}

外层循环表示依次从C中选取一种数。内层的第一个循环表示C中这个数能够取几次，内层的第二个循环表示，假设不选上一个数的话。要恢复状态。即把保存的上一个数删除（增加了多少个，就删除多少个）。

版权声明：本文博客原创文章。博客，未经同意，不得转载。