回溯法

回溯法是五大常用算法之一，回溯法也是一种暴力算法。我们在图的深度遍历时，其实就用到了回溯法，先选择一条路走，当出现走不通的情况，再返回上一种重新选择一种走法，直到遍历所有节点。常见的八皇后问题也能够使用回溯法来求解。

1. 八皇后问题

   回溯法解决八皇后问题时，是对每一行的每一个位置进行遍历，确定每一行可放皇后的位置。如果这一行没有可以放皇后的位置，则返回上一行，重新选择一个位置。依次类推。下面介绍八皇后问题最简洁的一种代码：

   void Queen(int row)  //参数row为现在正在执行到第几行
   {
       if(row == n)     //n是皇后数目，当程序能够正常执行到第8行，那自然是找到了一种解法
       	total++;
       else             //如果还没排到第8行，则遍历当前行所有列col
       {
           for(int col = 0; col != n; ++col)
           {
               c[row] = col;  //将当前col存储到数组c
               if(is_ok(row))  //使用is_ok()来检查row行col列能不能摆皇后
               	Queen(row+1); //如果可以，则递归调用queen
           }
       }
   }
   

   全部程序如下：

   #include
   #include
   using namespace std;
   
   int n = 8;
   int total = 0;
   int *c = new int(n);
   
   bool is_ok(int row)
   {
       for(int j = 0; j != row; ++j)
       {
           if(c[row] == c[j] || row + c[row] == j + c[j] || row - c[row] == j - c[j])
               return false;
       }
       return true;
   }
   
   void Queen(int row)  //参数row为现在正在执行到第几行
   {
       if(row == n)     //n是皇后数目，当程序能够正常执行到第8行，那自然是找到了一种解法
       	total++;
       else             //如果还没排到第8行，则遍历当前行所有列col
       {
           for(int col = 0; col != n; ++col)
           {
               c[row] = col;  //将当前col存储到数组c
               if(is_ok(row))  //使用is_ok()来检查row行col列能不能摆皇后
               	Queen(row+1); //如果可以，则递归调用queen
           }
       }
   }
   
   int main()
   {
       queen(0);
       cout<<total<<endl;
       return 0;
   }
   

2. 目标和问题

   class Solution {
   public:
       int findTargetSumWays(vector<int>& nums, int S) {
           int sum = 0;
           int index = 0;
           
           dfs(nums, sum, index, S);
           return res;
       }
       
       void dfs(vector<int>& nums, int sum, int index, int S)
       {
           if(index == nums.size())
           {
               if(sum == S)
               {
                   res++;
                   return;
               }
           }
           if(index < nums.size())
           {
               dfs(nums, sum + nums[index], index+1, S);
               dfs(nums, sum - nums[index], index+1, S);
           }
       }
   
   private:
       int res;
   };