leetcode笔记｜第十四周 回溯算法

第十四周 回溯算法

回溯算法是一种纯暴力搜索算法，可以解决组合问题、排列问题、子集问题、切割问题、棋盘问题…

401 二进制手表

class Solution:
    def readBinaryWatch(self, num: int) -> List[str]:
        # 暴力法：遍历hour和minite，bin().count("1")实现统计二进制表示中1的数量
        res = []
        for h in range(12):
            for m in range(60):
                if bin(h).count("1")+bin(m).count("1")==num:
                    res.append("%d:%02d" % (h,m))
        return res

面试题08.04 幂集

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        # 偷看答案,就是不断把最后一个元素加入到res已有元素中形成tmp，再加入res中
        res = [[],]
        for num in nums:
            res +=  [ele + [num] for ele in res]
        return res	

131 分割回文串

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        if not s: return [[]]
        if len(s)==1: return [[s]]
        res = []
        for i in range(1, len(s)+1):
            # 当分割前面是回文的时候
            if s[:i]==s[:i][::-1]:
                # 前面回文加入到后面的所有可能结果中组成最终结果，后面部分用回溯嘛
                res += [[s[:i]] + ele for ele in self.partition(s[i:])]
        return res

526 优美的排列

class Solution:
    def countArrangement(self, N: int) -> int:
        nums = set(range(1,N+1))
        used = set()
        res = 0
        def perfectlist(num):
            nonlocal res
            if num == N+1: # 判断回溯是否结束
                res += 1
                return
            for ele in nums-used:
                if num % ele == 0 or ele % num == 0:
                    used.add(ele) # 回溯，上一步会影响下一步的时候需要写入状态
                    perfectlist(num+1)
                    used.remove(ele) # 回溯，将状态重置到上一步，与上上行一起出现的

        perfectlist(1)
        return res

93 复原IP地址

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        def backtrack(allip, cnt, idx):
            if cnt == 4 and idx == len(s): # 回溯：判断是否应该结束了
                res.append(allip[1:])
                return
            if cnt > 4: # 回溯：非法状态直接结束
                return
            
            for i in range(min(3, len(s)-idx)): # 回溯：遍历所有可能的情况
                if s[idx] == '0': # 考虑遇到0直接回溯，不在后面加数字了
                    backtrack(allip+'.'+s[idx], cnt+1, idx+1)
                    break
                cur = ''
                for j in range(i+1):
                    cur += s[idx+j]
                if 0 <= int(cur) <= 255: 
                    backtrack(allip+'.'+cur, cnt+1, idx+j+1) # 进行下一步尝试，搜索该子树

        
        if len(s)<4 or len(s)>12: # 回溯：首先判断边界条件
            return []
        res = []
        backtrack('',0,0) # 回溯：根节点的输入
        return res

51 N皇后

困难，溜了溜了

10 正则表达式匹配

困难，打扰了