LeetCode刷题1：第八周

LeetCode刷题1：第八周

相关系列笔记：
LeetCode刷题：前言
LeetCode刷题1：第一周
LeetCode刷题1：第二周
LeetCode刷题1：第三周
LeetCode刷题1：第四周
LeetCode刷题1：第五周
LeetCode刷题1：第六周
LeetCode刷题1：第七周
LeetCode刷题1：第八周

前言

  【week 8】Topic：回溯法
    (1)1688.比赛中的配对次数
    (2)46.全排列
    (3)77.组合
    (4)131.分割回文串
    (5)22.括号生成

一、知识点

  在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

  也叫试探法，它是一种系统地搜索问题的解的方法。

1.1 基本思想：

  从一条路往前走，能进则进，不能进则退回来，换一条路再试。

1.2 一般步骤：

  • 定义一个解空间（子集树、排列树二选一）
  • 利用适于搜索的方法组织解空间。
  • 利用深度优先法搜索解空间。
  • 利用剪枝函数避免移动到不可能产生解的子空间。

1.3 子集树模板

  遍历子集树，时间复杂度 O(2^n)

  如果解的长度是不固定的，那么解和元素顺序无关，即可以从中选择0个或多个。例如：子集，迷宫，…

  如果解的长度是固定的，那么解和元素顺序有关，即每个元素有一个对应的状态。例如：子集，8皇后，…

  解空间的个数指数级别的，为2^n,可以用子集树来表示所有的解

  适用于：幂集、子集和、0-1背包、装载、8皇后、迷宫、…

1.4排列树模板

  遍历排列树，时间复杂度O(n!)

  解空间是由n个元素的排列形成，也就是说n个元素的每一个排列都是解空间中的一个元素，那么，最后解空间的组织形式是排列树

  适用于：n个元素全排列、旅行商、…

二、LeetCode例题

1688. 比赛中的配对次数

  给你一个整数 n ，表示比赛中的队伍数。比赛遵循一种独特的赛制：
    • 如果当前队伍数是 偶数 ，那么每支队伍都会与另一支队伍配对。总共进行 n / 2 场比赛，且产生 n / 2 支队伍进入下一轮。
    • 如果当前队伍数为 奇数 ，那么将会随机轮空并晋级一支队伍，其余的队伍配对。总共进行 (n - 1) / 2 场比赛，且产生 (n - 1) / 2 + 1 支队伍进入下一轮。
    返回在比赛中进行的配对次数，直到决出获胜队伍为止。
      示例 1：
        输入：n = 7
        输出：6
        解释：比赛详情：
          - 第 1 轮：队伍数 = 7 ，配对次数 = 3 ，4 支队伍晋级。
          - 第 2 轮：队伍数 = 4 ，配对次数 = 2 ，2 支队伍晋级。
          - 第 3 轮：队伍数 = 2 ，配对次数 = 1 ，决出 1 支获胜队伍。
          总配对次数 = 3 + 2 + 1 = 6
      示例 2：
        输入：n = 14
        输出：13
        解释：比赛详情：
          - 第 1 轮：队伍数 = 14 ，配对次数 = 7 ，7 支队伍晋级。
          - 第 2 轮：队伍数 = 7 ，配对次数 = 3 ，4 支队伍晋级。
          - 第 3 轮：队伍数 = 4 ，配对次数 = 2 ，2 支队伍晋级。
          - 第 4 轮：队伍数 = 2 ，配对次数 = 1 ，决出 1 支获胜队伍。
          总配对次数 = 7 + 3 + 2 + 1 = 13
      提示：
        • 1 <= n <= 200

  实现：

class Solution:
    def numberOfMatches(self, n: int) -> int:

        # a 比赛的场数
        # 分情况讨论：n 是偶数或者奇数
        
        a = 0
        while n > 1:
            if n % 2 == 0:
                a += n / 2
                n = n / 2
            else:
                a += (n - 1) / 2
                n = (n - 1) / 2 + 1
        return int(a)

46. 全排列

  给定一个 没有重复 数字的序列，返回其所有可能的全排列。
    示例:
      输入: [1,2,3]
      输出:
        [
         [1,2,3],
         [1,3,2],
         [2,1,3],
         [2,3,1],
         [3,1,2],
         [3,2,1]
        ]

  实现：

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:

    # 将第index位的数字与数组中后半段[index+1 : length]的数字依次交换
    # 完成交换后，则递归调用helper()函数，完成后续的数组中[index+1 : length]的交换
    # 当发现index等于数组长度，说明已经完成数组中所有数字的交换，输出结果

        res, length = [], len(nums)
        def helper(index):
            if index == length:
                res.append(list(nums))
            for i in range(index, length):
                nums[index], nums[i] = nums[i], nums[index]
                helper(index+1)
                nums[index], nums[i] = nums[i], nums[index]
        helper(0)
        return res

77. 组合

  给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
    示例:
      输入: n = 4, k = 2
      输出:
        [
         [2,4],
         [3,4],
         [2,3],
         [1,2],
         [1,3],
         [1,4],
        ]

  实现：

class Solution:
    def combine(self, n: int, k: int) -> [[int]]:
        # 回溯法
        res = []
        def backtrack(i, k, tmp):
            if k == 0:
                res.append(tmp)
                return
            for j in range(i, n+1):
                backtrack(j+1, k-1, tmp+[j])

        backtrack(1, k, [])
        return res

131. 分割回文串

  给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
    返回 s 所有可能的分割方案。
      示例:
        输入: “aab”
        输出:
          [
           [“aa”,“b”],
           [“a”,“a”,“b”]
           ]

  实现：

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        # 回溯算法
        res = [] # 结果变量
        state = [] # 状态变量

        def backward(state, i): # i，当前分割位置
            # 终止条件
            if i == len(s):
                res.append(state)
                return 
            
            for j in range(i+1, len(s)+1): # j，下一个分割位置
                temp = s[i:j] # 两个分割位置确定的字符串
                if temp == temp[::-1]: # 判断是否为回文
                    backward(state+[temp], j)
            
        backward([], 0)
        return res

22. 括号生成

   数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
      示例：
        输入：n = 3
        输出：[
           “((()))”,
           “(()())”,
           “(())()”,
           “()(())”,
           “()()()”
           ]

  实现：

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        #回溯法
        result = []
        def backtrack(left, right, tmp):
            if right > left or left > n: return
            if left + right == 2 * n:
                result.append(tmp)
                return
            backtrack(left + 1, right, tmp + '(')
            backtrack(left, right + 1, tmp + ')')
        backtrack(0, 0, '')
        return result