彻底搞懂回溯算法

回溯算法的框架与思想推荐labuladong的扒一扒回溯算法的裤子

回溯算法

回溯法（back tracking）（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”

通俗讲：回溯法可以理解为通过选择不同的岔路口寻找目的地，一个岔路口一个岔路口的去尝试找到目的地。如果走错了路，继续返回来找到岔路口的另一条路，直到找到目的地

通过看两个经典的例子来理解

八皇后

参考博客小白带你学–回溯算法

bool is_ok(int row){            //判断第row行设置的皇后是否与前row-1行在同一行，同一列，或者同一斜线上
    for (int j=0;j<row;j++)
    {
        if (queen[row]==queen[j]||row-queen[row]==j-queen[j]||row+queen[row]==j+queen[j])
            return false;       
    }
    return true;
}

void back_tracking(int row=0)    //算法函数，从第0行开始遍历
{
    if (row==n){t++;}           //判断若遍历完成，就进行计数, 统计解法个数    
    for (int col=0;col<n;col++)     //遍历棋盘每一列
    {
    	queen[row] = col;           //将皇后的位置记录在数组
        if (is_ok(row))             //判断皇后的位置是否有冲突
            back_tracking(row+1);   //递归，计算下一个皇后的位置
    }
}

LeetCode698. 划分为k个相等的子集

给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
示例 1： 输入： nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出： True
说明： 有可能将其分成 4 个子集（5），（1,4），（2,3），（2,3）等于总和。
注意:
1 <= k <= len(nums) <= 16
0 < nums[i] < 10000

这里提供三种解法，解法1、2都维护k个子集，且对nums数组排序后从大到小依次放入集合，都是常规解法

解法一

class Solution {
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        int sum = accumulate(nums.begin(),nums.end(),0);
        if(sum % k !=0){
            return false;
        }
        sum /= k;
        sort(nums.begin(),nums.end());
        vector<int> subset(k,0);
        int n=nums.size()-1;
        if(nums[n]>sum){
            return false;
        }
        //对数组中等于子集和sum的数进行处理
        while(n>=0 && nums[n]==sum){
            k--;
            n--;
        }
        return help(nums,subset,k,n,sum);
    }
    bool help(vector<int>& nums,vector<int>& subset,int k,int index,int sum){
        if(index < 0){
            return true;
        }
        for(int i=0;i<k;i++){
            subset[i] += nums[index];
            if(subset[i]==sum||(subset[i]<=sum-nums[0]&&help(nums,subset,k,index-1,sum))){
                return true;
            }
            subset[i] -= nums[index];
        }
        return false;
    }
};

解法二

class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        //因为题目限制条件不用担心溢出
        int sum = 0;
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        if(sum % k != 0){
            return false;
        }
        //求出子集的和
        sum = sum / k;
        //排序 小的放最前面大的放最后面
        Arrays.sort(nums);
        //如果子集的和小于数组最大的直接返回false
        if(nums[nums.length - 1] > sum){
            return false;
        }
        //建立一个长度为k的桶
        int[] arr = new int[k];
        //桶的每一个值都是子集的和
        Arrays.fill(arr, sum);
        //从数组最后一个数开始进行递归
        return help(nums, nums.length - 1, arr, k);
    }
    
    boolean help(int[] nums, int cur, int[] arr, int k){
        //已经遍历到了-1说明前面的所有数都正好可以放入桶里，那所有桶的值此时都为0，说明找到了结果，返回true
        if(cur < 0){
            return true;
        }
        //遍历k个桶
        for(int i = 0; i < k; i++){
            //如果正好能放下当前的数或者放下当前的数后，还有机会继续放前面的数（**剪枝**）
            if(arr[i] == nums[cur] || (cur > 0 && arr[i] - nums[cur] >= nums[0])){
                //放当前的数到桶i里
                arr[i] -= nums[cur];
                //开始放下一个数
                if(help(nums, cur - 1, arr, k)){
                    return true;
                }
                //这个数不该放在桶i中，从桶中拿回当前的数
                arr[i] += nums[cur];
            }
        }
        return false;
    }
}

解法三

解法3参考 LeetCode698. 划分为k个相等的子集
思路 “奇特” ：

先求出平均数avg，假如平均数avg不为整数，也就是说数组的数字总和不能平均的分为k份，那么直接返回false。
创建一个布尔数组flag，来记录nums数组中数字的状态（已用还是未用）， temp 初始为avg, temp的作用为记录当前子集的数字总和，当temp等于0时，当前这个子集也就可以确定。index是用来记录遍历数组时从哪个位置开始遍历，以防将前面的数字重新计算。
当k个子集全部求解完，返回true，如果一直求解不出，则返回false。当temp = 0 的时候，也就是新一个子集求解完，那么继续求解下一个子集，k-1，temp重新置为avg；当temp ！= 0 时，就是子集还未求解完，那么继续求解子集，继续从数组中取数字，递归求解。

class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        int sum = 0;
        int len = nums.length;
        for (int i = 0; i < len; i++) 
            sum += nums[i];
        
        if(sum % k != 0 ) return false;
        int avg = sum / k;
        boolean[] flag = new boolean[len];
        return help(nums,flag,avg,k,avg,0);
    }
    
    public static boolean help(int[] nums, boolean[] flag, int avg, int k, int temp, int index ){
 
        if (k == 0 ) return true;
        if (temp == 0)
            return help(nums,flag,avg,k-1,avg,0);
        for (int i = index; i < nums.length; i++) {
            if (flag[i] == true) continue;
            flag[i] = true;
            if(temp-nums[i]>=0 && help(nums,flag,avg,k,temp-nums[i],index+1)){
                return true;
            }
            flag[i] = false;
        }
        return false;
    }
}