回溯法——列举多维向量

1.回溯法概述

   对于单维或者低维向量进行搜索时，可以非常简单的使用循环来遍历。但是随着维度的增加要怎么进行遍历呢？没错，使用回溯法可以对多维向量进行exhaustive searching。

   它的通用编程模式：

backtrack( [v1,...,vn] )      {        if ( [v1,...,vn] is well-generated )        {            if ( [v1,...,vn] is a solution ) process solution;            return;        }             for ( x = possible values of vn+1 )            backtrack( [v1,...,vn, x] );    }         call backtrack( [] );   

2.回溯法经典例题

  1>列举数组（可以重复）

    

void backtrack1(vector< vector<int> > &res,vector<int> temp,int n){    if(n==0)    {        res.push_back(temp);        return ;    }    else    {            int i;            for(i=1;i<4;i++)            {                temp.push_back(i);                backtrack1(res,temp,n-1);                temp.pop_back();            }    }}int  main(){    vector< vector<int> > res;    vector<int> temp;    backtrack1(res,temp,3);    int i,j;    for(i=0;i<res.size();i++)    {        for(j=0;j<res[i].size();j++)        {            cout<<res[i][j]<<"  ";        }        cout<<endl;    }  return 0;}

列举简图：

2> 列出[1,2,3] 的所有全排列，排列中不能有重复，只可能是1,2,3;1,3,2;2,3,1;2,1,3;3,1,2;3,2,1;共6中情况。

int used[4]={0};void backtrack(vector< vector<int> > &res,vector<int> temp,int n){    if(n==0)    {        res.push_back(temp);        return ;    }    else    {            int i;            for(i=1;i<4;i++)            {                if(!used[i])                {                    used[i]=1;                    temp.push_back(i);                    backtrack(res,temp,n-1);                    temp.pop_back();                    used[i]=0;                }            }    }}

main函数是一样的，只需要该函数名称。

3>要求输出所有的1...n之间的k个数。

   比如：n=4,k=2;输出：

[  [2,4],  [3,4],  [2,3],  [1,2],  [1,3],  [1,4],]

class Solution {public:    vector<vector<int>> combine(int n, int k) {        vector<int>temp;        com(n,k,temp,0);        return res;    }    void com(int n,int k,vector<int> temp, int m)    {        if(k==0)        {            res.push_back(temp);            return ;        }        else        {            for(int i=1;i<=n;i++)            {                if(i>m)                {                    temp.push_back(i);                    com(n,k-1,temp,i);                    temp.pop_back();                }            }        }    }private:    vector<vector<int>> res;};

4>输出序列中所有和为固定值的子序列：

  例如：序列2，3，6，7 和为7,那么输出

                                                 [7]
                                                 [2, 2, 3]

class Solution {  private:      const int index_count;      vector<vector<int> > results;  public:      Solution() : index_count(10000) {};      // index记录当前找到的候选数字，n表示当前正在找第几个，n是index的下标不是candidates的下标      void backtrace(int target, int sum, vector<int> &candidates, int index[], int n)      {          if (sum > target)          {              return; // 回溯          }          if (sum == target)          {              vector<int> result;              for (int i = 1; i <= n; ++i)              {                  result.push_back(candidates[index[i]]);               }              results.push_back(result);              return; // 此处可以不加，如果不加return由于都是正整数，到下面的计算时会多进行一次无用的递归。          }            // 深度搜索，为了避免重复，每次从当前候选项索引到结尾，上面的i=index[n]可以看出          for (int i = index[n]; i < candidates.size(); ++i)          {              index[n+1] = i; // 记录当前考察的候选项索引              backtrace(target, sum+candidates[i], candidates, index, n+1);          }            // 深度搜索，为了避免重复，每次从当前候选项索引到结尾，上面的i=index[n]可以看出       //   for (int i = index[n]; i < candidates.size(); ++i)       //   {       //       index[n+1] = i+1;   // 记录当前考察的候选项索引并加一，下次考察是跳过上次考察过的元素，每轮每个元素值考察一次       //       backtrace(target, sum+candidates[i], candidates, index, n+1);       //   }      }      vector<vector<int> > combinationSum(vector<int> &candidates, int target) {          // Start typing your C/C++ solution below          // DO NOT write int main() function          sort(candidates.begin(), candidates.end());            int *index = new int[index_count];          memset(index, 0, sizeof(int)*index_count);                    results.clear();    // 提交到leetcode的测试系统上必须添加，它应该是使用一个对象测试所有测试用例。          backtrace(target, 0, candidates, index, 0);            delete[] index;            return results;      }  };

5> 给定只有1到9这9个数，选择k个数，它的和等于n。

      k=3,n=9.输出

[[1,2,6], [1,3,5], [2,3,4]]

class Solution {public:    vector<vector<int>> combinationSum3(int k, int n)     {        vector<int> temp;        sum(k,n,0,temp,0);        return res;    }        void sum(int k,int n,int f1,vector<int> temp,int m)    {        if(f1>n) return ;        if(f1==n && k==0) res.push_back(temp);        else        {            for(int i=1;i<10;i++)            {                if(i>m)                {                    //flag[i]=1;                    temp.push_back(i);                    sum(k-1,n,f1+i,temp,i);                    temp.pop_back();                    //flag[i]=0;                }                else                    continue;            }                        }    }private:    vector<vector<int>> res;    int flag[10]={0};};

6> 输出所有的括号对的个数

    例如n=3时。输出"((()))", "(()())", "(())()", "()(())", "()()()"

class Solution {public:    vector<string> generateParenthesis(int n)     {        string s;        generate(n,n,s,res);        return res;    }    void generate(int leftNum,int rightNum,string s,vector<string> &result)      {          if(leftNum==0&&rightNum==0)          {              result.push_back(s);          }          if(leftNum>0)          {              generate(leftNum-1,rightNum,s+'(',result);          }          if(rightNum>0&&leftNum<rightNum)          {              generate(leftNum,rightNum-1,s+')',result);          }      } private:    vector<string> res;};