回溯模板

回溯法：
链接：https://leetcode-cn.com/problems/restore-ip-addresses
给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址
参考解法：https://www.jianshu.com/p/014e50996391

class Solution(object):
    def restoreIpAddresses(self, s):
        #特殊条件判断 IP地址分为四段，即至少长度为4
        if len(s)<4:
            return []
        self.res = [] #总的路径集合
        self.path = []#每次的路径
        level = 1
        self.backtrace(s,[],level=1)
        return self.res
    def backtrace(self,selects,path,level):
        #1递归终止条件
        if len(selects) == 0 or level == 5:
            if len(selects) == 0 and level == 5:
                self.res.append(".".join(path))
                #  result.append(".".join(tmp_list))
            return
        for i in range(3): #每次至多选择三位数字
            if i<len(selects):#索引长度不能超过selects
                if self.isValid(selects[0:i+1]):
                    self.path.append(selects[0:i+1])#加入选择
                    self.backtrace(selects[i+1:],self.path,level+1)
                    self.path.pop()
        #需要撤销选择！！！这里的撤销，针对的是加入选择，因为for i in range(3)过程中加入其他选择

    def isValid(self, sub_s):
        if len(sub_s) > 1 and sub_s.startswith('0'):
            return False
        if 0 <= int(sub_s) <= 255:
            return True
        return False
                    # self.path.pop()#撤销选项

这里撤销选择的理解：为什么需要撤销选择，其实答案很简单，看上图决策树的最左边的分支，当遍历到 2.5.5.2 发现不合适的时候，需要回溯到 2.5.5，然后选择 25，也就是说最后的 2 加入 tmp_list 之后，判断不合适，递归返回之后，我们需要把 2 删除，然后腾出空间放 25，这也是为什么叫回溯算法的原因，遇到不符合目标的，就回头重新选择。当然了，遇到合适的，也要重新选择，是因为我们要选出所有合法的 ip 地址。
建议模板：https://labuladong.gitbook.io/algo/suan-fa-si-wei-xi-lie/hui-su-suan-fa-dfs-suan-fa/hui-su-suan-fa-xiang-jie-xiu-ding-ban
https://leetcode-cn.com/problems/permutations/solution/46-quan-pai-lie-hui-su-fa-by-jue-qiang-z-jym3/

leetcode 47 给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

class Solution(object):
    def permuteUnique(self, nums):

        res = []
        # ans = []
        n = len(nums)
        # path = []
        if not nums:
            return []


        def backtrace(selects,path,level):
            if level == n+1:
                res.append(path[:])
                return

            for i in range(len(selects)):
                if i >0 and selects[i] == selects[i-1]:
                    continue
                path.append(selects[i])
                backtrace(selects[:i]+selects[i+1:],path,level+1)
                path.pop()
        nums.sort() #排序去重

        backtrace(nums,[],1)



        return res