# 回溯算法

回溯算法

简介：

• 使用场景：当问题要求找出所有解集或者要求回答满足约束的最优解时，往往需要回溯法。
• 方法定义：具有限界函数的深度优先生成法称为回溯法。
• 基本做法：回溯法本质是搜索，是能避免不必要搜索的穷举式搜索。通常，回溯法在问题的解空间树中，按照深度优先策略，从根节点出发搜索解空间树。算法搜索到解空间树的任意结点时，先判断该节点是否包含问题的解：1）如果不包含，则跳过以该结点为根的树的搜索，逐层向祖先节点回溯；2）否则进入该子树，继续按深度优先搜索策略搜索；
  注：这边需要注意的点是如何跳过，如何回溯？

回溯法解题框架

递归回溯

回溯法对解空间作深度优先搜索时，使用递归方法实现回溯法。

void backtrack (int t)
{
    if (t>n) 
        output(x);
    else //当前扩展节点的子树的起始/终止节点。
        for (int i=f(n,t);i<=g(n,t);i++) {
            x[t]=h(i);
            if (constraint(t)&&bound(t))
                backtrack(t+1);
    }
}

迭代回溯

采用树的非递归深度优先遍历算法，可将回溯法表示为一个非递归迭代过程。

void iterativeBacktrack (){
    int t=1;
    while (t>0) {
        if (f(n,t)<=g(n,t))
            for (int i=f(n,t);i<=g(n,t);i++) {
                x[t]=h(i);
                if (constraint(t)&&bound(t)) {
                    if (solution(t)) output(x);
                        else t++;}
            }
        else t--;
    }
}

子集树

典型例子：装载问题；0-1背包问题；最大团问题;求所有子集

void backtrack (int t){
    if (t>n) 
        output(x);
    else
        for (int i=0; i<=1; i++) {
            x[t]=i;
            if (legal(t)) backtrack(t+1);
        }
}

(leetcode-77) 给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def backtrack(nums,index,path,k):
            if len(path) == k:
                res.append(path[:])
                return
            for i in range(index,len(nums)):
                backtrack(nums,i+1,path+[nums[i]],k)
        res = []
        backtrack(list(range(1,n+1)),0,[],k)
        return res

(leetcode-78) 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。说明：解集不能包含重复的子集

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        def dfs(nums,index,path):
            res.append(path[:])
            for i in range(index,len(nums)):
                dfs(nums,i+1,path+[nums[i]])
        res = []
        nums.sort()
        dfs(nums,0,[])
        return res

(leetcode-90) 给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。说明：解集不能包含重复的子集。

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        def dfs(nums,index,path):
            res.append(path[:])
            for i in range(index,len(nums)):
                if i>index and nums[i] == nums[i-1]:
                    continue
                dfs(nums,i+1,path+[nums[i]])
        res = []
        nums.sort()
        dfs(nums,0,[])
        return res

(leetcode-216) 找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。说明：所有数字都是正整数。解集不能包含重复的组合

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        def backtrack(nums,index,n,k,path):
            if 0==k and n==0:
                res.append(path[:])
                return 
            for i in range(index,9):
                if nums[i] <= n:
                    backtrack(nums,i+1,n-sum([nums[i]]),k-1,path+[nums[i]])
        res = []
        nums = list(range(1,10))[::-1]
        backtrack(nums,0,n,k,[])
        return res

(leetcode-416) 给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。注意:每个数组中的元素不会超过 100.数组的大小不会超过 200
注：刚开始提前判断的时候要注意各种情况，第二，学会这种只要满足就返回的方式

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        div,mod = divmod(sum(nums),2)
        if mod==1 or max(nums)>div:
            return False
        tar = sum(nums)//2
        
        def backtrack(nums,index,t,flags):
            if t == 0:
                return True
            for i in range(index,len(nums)):
                if nums[i] <= t:
                    if backtrack(nums,i+1,t-nums[i],flags):
                        return True
            return False
            
        res = []
        nums.sort(reverse=True)
        flags=[0]*len(nums)
        if backtrack(nums,0,tar,flags):
            return True
        return False

(leetcode-698) 给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
注：需要开动一下脑子，做一些变换。每个数一定能被分到一个集合中去

class Solution:
    def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:
        div, mod = divmod(sum(nums),k)
        if mod!=0 or max(nums)>div:
            return False
        
        def backtrack(nums,targets,i):
            if i==len(nums):
                return True
            for j,v in enumerate(targets):
                if nums[i]<=v:
                    targets[j]-=nums[i]
                    if backtrack(nums,targets,i+1):
                        return True
                    targets[j]+=nums[i]
            return False
        targets = [div]*k
        nums.sort(reverse=True)
        return backtrack(nums,targets,0)

排列树

典型例子：全排列问题

void backtrack (int t){
    if (t>n) 
        output(x);
    else
        for (int i=t; i<=n; i++) {
            swap(x[t], x[i]);
            if (legal(t)) backtrack(t+1);
            swap(x[t], x[i]);
    } 
} 

def perm(data,begin,end):
    if begin == end:
        print(data)
    else:
        j = begin
        for i in range(begin,end):
            data[i] ,data[j] = data[j], data[i]
            perm(data,begin+1,end)
            data[i] ,data[j] = data[j], data[i]
perm(list(range(3)),0,3)

(leetcode-46) 给定一个没有重复数字的序列，返回其所有可能的全排列。

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def dfs(nums,index):
            if index ==len(nums):
                res.append(nums[:])
            for i in range(index,len(nums)):
                nums[i],nums[index] = nums[index], nums[i]
                dfs(nums,index+1)
                nums[i],nums[index] = nums[index], nums[i]
        
        res = []
        dfs(nums,0)
        return res

(leetcode-526) 假设有从 1 到 N 的 N 个整数，如果从这 N 个数字中成功构造出一个数组，使得数组的第 i 位 (1 <= i <= N) 满足如下两个条件中的一个，我们就称这个数组为一个优美的排列。条件：第 i 位的数字能被 i 整除,i 能被第 i 位上的数字整除，现在给定一个整数 N，请问可以构造多少个优美的排列？

class Solution:
    def countArrangement(self, N: int) -> int:
        flags = [0]*(N+1)
        nums = list(range(N+1))
        self.res = 0
        self.backtrack(nums,1,flags)
        return self.res

    def backtrack(self,nums,index,flags):
        if index==len(nums):
            self.res += 1
            return
        for i in range(1,len(nums)):
            if flags[i] == 0 and (index%i==0 or i%index==0):
                flags[i] = 1
                self.backtrack(nums,index+1,flags)
                flags[i] = 0

回溯算法三要素：

• 选择 ( choice )
• 约束 ( constraint )
• 目标 ( goal )