【算法-面试】回溯法专题

已于 2022-03-01 21:31:36 修改
阅读量1k 收藏
点赞数
分类专栏： |算法| 文章标签： 算法 面试 leetcode 回溯法
于 2022-01-30 16:29:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzk2014/article/details/122753820
版权

1. 回溯法

回溯法主要体现在排列、组合、子集问题上。

Leetcode上的题目如下：

  • 22 括号⽣成(组合问题)
  • 37 解数独(排列问题)
  • 39 组合总和
  • 40 组合总和 II
  • 46 全排列
  • 47 全排列 II
  • 51 N 皇后(排列问题)
  • 77 组合
  • 78 子集
  • 90 子集 II
  • 494 ⽬标和(组合问题)
  • 698 划分为 k 个相等的⼦集(子集问题)

主要思想

  1. 子集问题可以利用数学归纳思想，假设已知一个规模较小的问题的结果，思考如何推导出原问题的结果。也可以用回溯算法，要用 start 参数排除已选择的数字。
  2. 组合问题利用的是回溯思想，结果可以表示成树结构，我们只要套用回溯算法模板即可，关键点在于要用一个 start 排除已经选择过的数字。
  3. 排列问题是回溯思想，也可以表示成树结构套用算法模板，不同之处在于使用 contains 方法排除已经选择的数字，这里主要是和组合问题作对比。
    1. contains方法用于递归算法backtrack的for循环内部的判断，用于排除已经选中的目标

2. 题目

【22. 括号⽣成】

# coding = "utf-8"
def generateParenthesis(n):
    '''
    数字 n 代表⽣成括号的对数，请你设计⼀个函数，⽤于能够⽣成所有可能的并且有效的括号组合。
    有效括号组合需满⾜：左括号必须以正确的顺序闭合。
    leetcode:22. 括号⽣成
    input:n=3
    output:["((()))","(()())","(())()","()(())","()()()"]
    思路：
        1. 利用回溯法，将所有的2n个括号进行组合
        2. 回溯判断条件：
            1) 当左右括号计数同时为n个的时候，说明括号数正好
            2) 当左右括号其中一个大于n时，说明括号不合法
            3) 当右括号数大于左括号时，说明括号不合法，这个判断条件很重要，可以筛选掉类似"())("这类不合法的组合
        3. 初始条件：左右括号数为0，path为""
        4. 入参：入参即左右括号数，记录路径的path
    '''
    if n == 0:
        return []
    res = []

    def backtrack(left, right, trace):
        if left == n and right == n:
            res.append(trace)

        if left > n or right > n or left < right:
            return
        backtrack(left + 1, right, trace + "(")
        backtrack(left, right + 1, trace + ")")

    backtrack(0, 0, "")
    print(res)
    return res

【37. 解数独】

def solveSudoku(board):
    '''
    编写⼀个程序，通过填充空格来解决数独问题，数独的解法需遵循如下规则：
    1、数字 1-9 在每⼀⾏只能出现⼀次。
    2、数字 1-9 在每⼀列只能出现⼀次。
    3、数字 1-9 在每⼀个以粗实线分隔的 3x3 宫内只能出现⼀次。
    数独部分空格内已填⼊了数字，空⽩格⽤ '.' 表示。
    leetcode: 37. 解数独
    input:board =   [["5","3",".",".","7",".",".",".","."],
                    ["6",".",".","1","9","5",".",".","."],
                    [".","9","8",".",".",".",".","6","."],
                    ["8",".",".",".","6",".",".",".","3"],
                    ["4",".",".","8",".","3",".",".","1"],
                    ["7",".",".",".","2",".",".",".","6"],
                    [".","6",".",".",".",".","2","8","."],
                    [".",".",".","4","1","9",".",".","5"],
                    [".",".",".",".","8",".",".","7","9"]]
    output：[["5","3","4","6","7","8","9","1","2"],
            ["6","7","2","1","9","5","3","4","8"],
            ["1","9","8","3","4","2","5","6","7"],
            ["8","5","9","7","6","1","4","2","3"],
            ["4","2","6","8","5","3","7","9","1"],
            ["7","1","3","9","2","4","8","5","6"],
            ["9","6","1","5","3","7","2","8","4"],
            ["2","8","7","4","1","9","6","3","5"],
            ["3","4","5","2","8","6","1","7","9"]]
    思路：
        1. 回溯算法
        2. 每个格子遍历1-9，遇到不合法的数字则跳过：
            1). 横向数字有重复的
            2). 竖向数字有重复的
            3). 九个格子内的数字有重复的
        3. 如果找到一个合适的数字就找下一个空格
    '''
    m, n = 9, 9

    def backtrace(board, i, j):
        if j == m:
            # 到最后一列，触发下一行
            return backtrace(board, i + 1, 0)

        if i == m:
            # 到最后一行，触发base case
            return True

        if board[i][j] != '.':
            # 由于先判断j在前，所以不用担心下一个j即j+1会越界
            return backtrace(board, i, j + 1)

        for ch in range(1, 10):
            if not is_valid(board, i, j, str(ch)):
                continue
            board[i][j] = str(ch)
            if backtrace(board, i, j + 1):
                return True
            board[i][j] = '.'

        return False

    def is_valid(board, row, col, n):
        for i in range(9):
            if board[row][i] == n:
                return False
            if board[i][col] == n:
                return False
            if board[(row / 3) * 3 + i / 3][(col / 3) * 3 + i % 3] == n:
                return False
        return True

    backtrace(board, 0, 0)
    return board

【78. ⼦集】

def subsets(nums):
    '''
    输入一个不包含重复数字的数组，要求算法输出这些数字的所有子集。
    解集不能包含重复的⼦集。你可以按任意顺序返回解集
    leetcode: 78. ⼦集
    input:nums = [1,2,3]
    output:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
    思路：
        1. [1,2,3]的子集是
        2.
        3.
    '''
    import copy
    path, res = [], []

    def backtrack(start, trace):
        # 由于python是取的标签，需要copy下
        t = copy.copy(trace)
        res.append(t)
        for i in range(start, len(nums)):
            trace.append(nums[i])
            backtrack(i + 1, trace)
            trace.pop()

    backtrack(0, path)
    print(res)
    return res

【77. 组合】

def combine(n, k):
    '''
    输入两个数字 n, k，算法输出 [1..n] 中 k 个数字的所有组合。
    leetcode: 77. 组合
    input: n = 4, k = 2
    output:
        [
            [2,4],
            [3,4],
            [2,3],
            [1,2],
            [1,3],
            [1,4],
        ]
    思路：
        1. 回溯
        2. 注意是从1开始的，因此range的时候尾部+1，即range(start, n + 1)
        3. 更新start部分
    '''
    import copy
    res, path = [], []

    def backtrace(start, path):
        if len(path) == k:
            p = copy.copy(path)
            res.append(p)
            return

        for i in range(start, n + 1):
            path.append(i)
            backtrace(i + 1, path)
            path.pop()

    backtrace(1, path)
    print(res)
    return res

【46. 全排列】

def permute(nums):
    '''
    输入一个不包含重复数字的数组 nums，返回这些数字的全部排列。
    leetcode:46. 全排列
    input:[1,2,3]
    output:
        [
         [1,2,3],
         [1,3,2],
         [2,1,3],
         [2,3,1],
         [3,1,2],
         [3,2,1]
        ]
    思路：
        1. 回溯法
        2. 需要判断提出无效排列，比如[1,1,1], [1,2,1]
        3.
    '''
    import copy
    res, path, n = [], [], len(nums)

    def backtrace(path):
        if len(path) == n:
            p = copy.copy(path)
            res.append(p)
            return

        for i in range(n):
            # 排除的条件
            if nums[i] in path:
                continue

            path.append(nums[i])
            backtrace(path)
            path.pop()

    backtrace(path)
    print(res)
    return res

【51. N 皇后】


def solveNQueens(n):
    '''
    给你一个 N×N 的棋盘，让你放置 N 个皇后，使得它们不能互相攻击。
    攻击：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。
    leetcode: 51. N 皇后
    input: n
    output:
    思路：
        1. 加入判断条件的回溯法，本质上是一个排列问题
        2. is_valid函数用来判断Q的位置是否合适，判断同一列、左上、右上是否有Q
        3. 同一行不需要判断是因为有撤销选择，撤销后，该行不存在Q
    '''
    import copy
    board = [['.'] * n for _ in range(n)]
    res = []

    def backtrace(board, row):
        if row == n:
            b = copy.deepcopy(board)
            res.append(b)
            return
        for col in range(n):
            # 排除的条件
            if not is_valid(board, row, col):
                continue

            board[row][col] = 'Q'
            backtrace(board, row + 1)
            board[row][col] = '.'

    def is_valid(board, row, col):
        # 同一列
        for i in range(n):
            if board[i][col] == 'Q':
                return False
        # 右上方
        i, j = row - 1, col + 1
        while i >= 0 and j < n:  # 注意循环条件是带0的
            if board[i][j] == 'Q':
                return False
            i -= 1
            j += 1

        # 左上方
        i, j = row - 1, col - 1
        while i >= 0 and j >= 0:  # 注意循环条件是带0的
            if board[i][j] == 'Q':
                return False
            i -= 1
            j -= 1
        return True

    backtrace(board, 0)
    print(res)
    print(len(res))
    return board

【494. ⽬标和】

def findTargetSumWays(nums, target):
    '''
    给你⼀个整数数组 nums 和⼀个整数 target，向数组中的每个整数前添加 '+' 或 '-'，然后串联起所有整数，可以构造⼀个表达式。
    例如，nums = [2, 1]，可以在 2 之前添加 '+'，在 1 之前添加 '-'，然后串联起来得到表达式 "+2-1"。
    返回可以通过上述⽅法构造的、运算结果等于 target 的不同表达式的数⽬。
    leetcode: 494. ⽬标和
    input:nums = [1,1,1,1,1], target = 3
    output:5
        ⼀共有 5 种⽅法让最终⽬标和为 3。
        -1 + 1 + 1 + 1 + 1 = 3
        +1 - 1 + 1 + 1 + 1 = 3
        +1 + 1 - 1 + 1 + 1 = 3
        +1 + 1 + 1 - 1 + 1 = 3
        +1 + 1 + 1 + 1 - 1 = 3
    思路：
        1. 回溯法
            1) 本质上是组合问题，给定一个start值
            2) 一次遍历需要做两次选择，一次是选择"+"，另一次是选择"-"
            3) base case是start达到数组的长度和s(路径或者本题的运算值)值与target相等
        2. 动态规划
            1). sum(A)-sum(B)=target => sum(A)=target+sum(B)
            2). 2sum(A) = target+sum(B)+sum(A) => sum(A)=(target+sum(nums))/2
            3). 转换为求subsets(nums, sum(A)), 即nums中存在几个子集，使得其和为(target+sum(nums))/2
            4). 转换为有一个背包的容量为sum(A), 有N个物品，每个物品重量为nums[i-1]，每个物品只放一次，有多少种不同的方法存放？
            5). 状态：背包的容量和可选择的物品
                选择：装背包和不装背包
                dp数组：dp[i][j]代表前i个物品中，背包容量为j，有dp[i][j]种方法存放
                base case：dp[0][.]代表没有物品，自然存放方法为0；dp[.][0]代表载重为0，那么什么都不放也是一种选择，因此为1
                状态
    '''

    class Track:
        def __init__(self, nums, target):
            self.res = 0
            self.nums_size = len(nums)
            self.target = target

        def backtrace(self, i, s):
            if i == self.nums_size:
                if s == self.target:
                    self.res += 1
                return
            # 选择"+"
            s += nums[i]
            self.backtrace(i + 1, s)
            s -= nums[i]

            # 选择"-"
            s -= nums[i]
            self.backtrace(i + 1, s)
            s += nums[i]

    class DP:
        def __init__(self, nums, target):
            self.nums = nums
            self.target = target
            self._sum = 0
            self._target = 0

        def find_ways(self):
            for num in self.nums:
                self._sum += num

            # 剔除目标值大于全是和值的情况 以及 和值与目标值加起来为奇数的情况
            if self._sum < self.target or (self._sum + target) % 2 == 1:
                return 0

            # 根据公式得到新的target
            self._target = (self._sum + self.target) // 2

            return self.subsets()

        def subsets(self):
            n = len(self.nums)
            dp = [[0] * (self._target + 1) for _ in range(n + 1)]
            for i in range(n + 1):
                dp[i][0] = 1

            for i in range(1, n + 1):
                for j in range(self._target + 1):
                    # 背包容量足
                    if j >= self.nums[i - 1]:
                        # dp[i - 1][j]表示不把物品放入背包，结果取决于上一个j容量时的状态
                        # dp[i - 1][j - self.nums[i - 1]]表示把物品放入背包，结果取决于上一个容量为j - self.nums[i - 1]容量时的状态
                        dp[i][j] = dp[i - 1][j] + dp[i - 1][j - self.nums[i - 1]]
                    # 背包容量不足
                    else:
                        dp[i][j] = dp[i - 1][j]
            print(dp)
            return dp[n][self._target]

    t = Track(nums, target)
    t.backtrace(0, 0)
    print(t.res)

    dp = DP(nums, target)
    res = dp.find_ways()
    # res = dp.subsets()
    print(res)
    return res

【698. 划分为 k 个相等的⼦集】


def canPartitionKSubsets(nums, k):
    '''
    给定⼀个整数数组 nums 和⼀个正整数 k，找出是否有可能把这个数组分成 k 个⾮空⼦集，其总和都相等。
    leetcode: 698. 划分为 k 个相等的⼦集
    input:nums = [4, 3, 2, 3, 5, 2, 1], k = 4
    output:True
    思路：
        1.
        2.
        3.
    '''

    class Trace:
        def __init__(self, nums, target, k):
            self.bucket = [0] * k
            self.k = k
            self.nums = nums
            self.target = target

        def backtrace(self, index):
            if len(self.nums) == index:
                for i in range(self.k):
                    if self.bucket[i] != self.target:
                        return False
                return True

            for i in range(self.k):
                if self.bucket[i] > self.target:
                    return False

                self.bucket[i] += self.nums[index]
                if self.backtrace(index + 1):
                    return True
                self.bucket[i] -= self.nums[index]

            return False

    if len(nums) < k:
        return False
    s = 0
    for num in nums:
        s += num
    if s % k != 0:
        return False
    target = s // k

    t = Trace(nums, target, k)
    res = t.backtrace(0)
    print(res)
    return res

【测试例】


if __name__ == "__main__":
    # generateParenthesis(3)
    # subsets([1, 2, 3])
    # combine(4, 2)
    # permute([1, 2, 3])
    # solveNQueens(8)
    # findTargetSumWays([1, 1, 1, 1, 1], 3)
    canPartitionKSubsets([4, 3, 2, 3, 5, 2, 1], 4)
    canPartitionKSubsets([4, 3, 2, 3, 5, 2, 5], 4)
alexliu2360
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华为OD机试真题 Java 实现【组装新的数组】【2023Q1 200分】
学Java，找哪吒
05-24 1070
本专栏包含了最新最全的2023年华为OD机试真题，有详细的分析和Java解答。已帮助1000+同学顺利通过OD机考。专栏会持续更新，每天在线答疑。给你一个整数M和数组N,N中的元素为连续整数，要求根据N中的元素组装成新的数组R。第一行输入是连续数组N，采用空格分隔；输出的是组装办法数量，int类型。
【200分】【组装新的数组】
weixin_54707168的博客
02-12 245
我们从数组的第一个元素开始，逐个尝试将当前元素放入组装数组中，并递归搜索后续元素，同时更新当前的元素总和。基于上述思路，我们可以编写深度优先搜索的函数，递归地搜索组装方案的可能性，并在满足条件时更新计数器。这个算法的时间复杂度取决于搜索的深度，最坏情况下可能达到 O(2^n)，其中 n 是输入数组的长度。更近的元素都已经被选取，那么我们找到了一个合法的组装方案，返回搜索的结果加一。，那么这个方案是不合法的，我们返回搜索的结果；3.R中的元素最多只能有1个不在N中，且比N中的数字都要小（不能为负数）
计算机体系结构重点整理.docx
05-08
计算机体系结构重点整理.docx
2023华为OD机试真题【组装数组】
wtswts1232的博客
04-11 604
3.R中的元素最多只能有1个不在N中，且比N中的数字都要小(不能为负数) 输入描述 第一行输入是连续数组N，采用空格分隔第二行输入数字M 输出描述 输出的是组装办法数量，int类型。当当前总和小于等于m且差值小于nums中的最小值，则计数器加1；对于每一个数值，都需要尝试选取和不选取两种情况，进入递归搜索。备注 1≤M≤30 1 ≤ N.length ≤ 1000。说明 共两种组装办法，分别是[2,2,1]，[2,3]说明 只有1种组装办法，就是[2,2,1]2.R中的元素可以从N中重复选取。
面试题中的回溯算法
Eerrly的博客
11-14 495
回溯算法
算法面试题--正负交替
数据小冰的博客
10-17 4439
算法面试题之数组元素正负交替的思路分析与实现
算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程
08-11
"算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程"提供了一种高效的学习方式，旨在帮助求职者提升自己的算法水平，更好地应对包括Google在内的顶级科技公司的面试挑战。 本课程主要涵盖了以下几个方面...
天津大学考研面试算法专题（很全面）
12-21
6. **回溯法**：当面临多种选择时，通过试探所有可能的解决方案并逐一排除不合适的，直到找到正确答案。如八皇后问题、数独问题等。 7. **分治策略**：将大问题分解为两个或更多的相同或相似的子问题，再将子问题的...
天津大学计算机考研面试（复试）算法专题（很全面）
01-03
5. **回溯法与贪心策略**：回溯法常用于解决组合优化问题，如八皇后问题、N皇后问题等；贪心策略则是在每一步选择局部最优解，以期望达到全局最优，如霍夫曼编码。 6. **数据结构**：链表、栈、队列、树（二叉树、...
面试专题及答案压缩.zip
01-10
其次，算法是考察技术能力的重要部分，例如排序算法（冒泡、选择、插入、快速、归并等）、查找算法（线性、二分查找等）、动态规划、贪心算法、回溯法等。掌握算法原理，并能用代码实现是面试官通常会问到的问题。 ...
数据结构面试专题.zip
12-23
"数据结构面试专题.zip"文件包含了对这个主题的深入探讨，特别是针对面试的准备。 文档"数据结构面试专题.docx"可能涵盖了以下几个关键知识点： 1. **基本数据结构**：数组、链表、栈和队列是最基础的数据结构。...
【华为OD机试真题 python】组装新的数组【2023 Q1 | 200分】
无痕de泪的博客
02-28 875
华为OD机试 Python OD笔试 组装新的数组：给你一个整数M和数组N,N中的元素为连续整数，要求根据N中的元素组装成新的数组R
华为OD机试真题-组装新的数组 【2023.Q1】
qq_37870576的博客
05-10 194
3.R中的元素最多只能有1个不在N中，且比N中的数字都要小(不能为负数)题意主要是从N当中选取若干元素，使得元素之和满足。首先，对数组nums进行排序，并找到数组中的最小值。共两种组装办法，分别是[2,2,1]，[2,3]，表示当前组合数已经超过目标和，返回当前计数值。，表示当前组合数满足条件，返回当前计数值加1。只有1种组装办法，就是[2,2,1]2.R中的元素可以从N中重复选取。1.R中元素总和加起来等于M。
华为OD机试 - 组装新的数组（Java & JS & Python）
伏城之外的博客
01-06 4833
2022.Q4 已支持Java、JavaScript、Python，全组合
2023荣耀校招机试（java&python&C++）组装新的数组
KALA51773的博客
03-16 901
给你一个整数M和数组N，N中的元素为连续整数，要求根据N中的元素组装成新的数组R
Python入门：之九--列表生成式
Asukaaaa的博客
04-04 439
一、列表生成式 使用列表生成式找出1～num之间的所有质数 使用列表生成式找出目录/var/log下以.log结尾的文件 练习： 给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整 数，并输出结果。输 入值小于1000。 如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别 为(5,5),(3,7)） [2,3,5,7]...
NOI OpenJudge 2722 和数
xsh_fu的博客
08-06 1310
NOI OpenJudge ch0102/2722 和数，全面分析版
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值