和为固定值的所有序列

1.问题描述

   给定一个随意的向量，找到和为固定值的所有不同的序列。

   例如:向量10,1,2,7,6,1,5 和为8

   应该得到序列:

   [1,7]

   [1,2,5]

   [2,6]

   [1,1,6]

   要求：序列中所有值都是整数，输出元素是从小到大排序的。输出的集合不能有重复的;

2.解法

   解析：1：因为要求输出是排序的，那么可以首先对序列排序,可以使用快速排序。

               2：排完序后，当遇到数大于和时，就没与必要再考虑后面的数了，因为所有的数都是整数.

               3：采用递归方法，从第一个数开始，如果包括这个数时，则需要在剩下的所有数当中找和减去刚才这个数。

                     不包括这个数时，则剩下的所有数中找和的序列，这样规模也就减小了。

               4：另外找的集合不能包括重复的序列，可以采用set集合。

<span style="font-size:14px;">class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) 
    {
        qsort(candidates,0,candidates.size()-1);
        vector<int>f1;
        combinationSum(candidates,target,f1,0);
        
        set<vector<int>>::iterator iter=ans.begin();
        while(iter!=ans.end())
        {
            res.push_back(*iter);
            iter++;
        }
        
        return res;
    }
    
    void combinationSum(vector<int> &can, int target, vector<int> f1,int begin)
    {
        if( 0 == target )
        {
           // res.push_back(f1);
           ans.insert(f1);
            
        }
        if(target<0 || begin>=can.size() || can[begin]>target)
        { 
            return;  
        }
        if(target>0)
        {
            f1.push_back(can[begin]);
            begin++;
             
            combinationSum(can,target-can[begin-1], f1,begin);
            
            f1.pop_back();
            combinationSum(can,target,f1,begin);
        }
    }
    
    void swap(int *a,int *b)
    {
        int temp=*a;
        *a=*b;
        *b=temp;
    }
    
    int partition(vector<int>& array, int left, int right)
    {
        int pivot = array[right];
        int pos = left-1;
        for(int index = left; index < right; index++)
        {
            if(array[index] <= pivot)
                swap(&array[++pos], &array[index]);
        }
        swap(&array[++pos], &array[right]);
        return pos;//返回 pivot 所在位置
    }
    
    void qsort(vector<int>& can,int begin,int end)
    {
        if(begin<end)
        {
            int mid=partition(can,begin,end);
            qsort(can,begin,mid-1);
            qsort(can,mid+1,end);
        }
    }
    
    private:
      vector<vector<int>> res;
      set<vector<int>> ans;
};</span>

该方法是从递归的角度考虑的，编程比较复杂，但是，还有一种比较简单的解法——回溯法。