LeetCode回溯问题小结

最新推荐文章于 2025-06-23 20:38:48 发布

原创最新推荐文章于 2025-06-23 20:38:48 发布 · 370 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #Python #回溯

LeetCode 专栏收录该内容

24 篇文章

订阅专栏

本文深入探讨了回溯算法的基本思想及其实现，通过多个经典案例如括号生成、组合总和、N皇后问题和全排列等，详细解析了算法的设计与应用。文章重点讲解了如何确定终止条件和前进策略，帮助读者掌握回溯算法的核心。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

回溯问题的基本思路，直观的来说就是尝试所有的情况，如果行不通则返回上一步，再继续尝试下一种情况。

回溯问题也可以被认为是有剪枝的深度优先搜索，关键就是要找到终止条件与如何前进。

22. 括号生成

class Solution:
    def __init__(self):
        self.res = []
        
    def generateParenthesis(self, n: int) -> List[str]:
        left, right = n, n
        self.generater("", left, right)
        return self.res
        
    def generater(self, output, left, right):
        if left == 0 and right == 0:
            self.res.append(output)
        elif left <= right and left >= 0:
            self.generater(output+"(", left-1, right)
            self.generater(output+")", left, right-1)

39. 组合总和

class Solution(object):
    def __init__(self):
        self.res = []
        
    def combinationSum(self, candidates, target):
        candidates = sorted(candidates)
        output = []
        self.choose(output, candidates, target, 0)
        return self.res
    
    def choose(self, output, nums, target, index):
        if target == 0:
            self.res.append(output)
            return
        elif output and target < output[-1]:
            return
        
        for i in range(index, len(nums)):
            self.choose(output+[nums[i]], nums, target-nums[i], i)

40. 组合总和 II

class Solution(object):
    def __init__(self):
        self.res = []
    def combinationSum2(self, candidates, target):
        nums = sorted(candidates)
        output = []
        self.choose(output, nums, target, 0)
        return self.res
        
    def choose(self, output, nums, target, index):
        if target == 0 and output not in self.res:
            self.res.append(output)
            return
        elif output and target < output[-1]:
            return 
        for i in range(index, len(nums)):
            self.choose(output+[nums[i]], nums, target-nums[i], i+1)

N皇后

def check(board, row, col):
    i = 0
    for i in range(row):
        if abs(board[i]-col) == 0 or abs(board[i]-col) == abs(i-row):
            return False
    return True

def eightqueen(board, row, res):
    border = len(board)
    if row == border:
        x = board[:]
        res.append(x)
        for i,col in enumerate(board):
            print('□ ' * col + '■ ' + '□ ' * (len(board) - 1 - col))
        print("")

    for col in range(border):
        if check(board, row, col):
            board[row] = col
            eightqueen(board, row+1, res)

board = [0 for i in range(4)]
res = []
eightqueen(board, 0, res)
len(res)

全排列

def generate(nums):
    res = []
    if len(nums) == 0: return []
    if len(nums) == 1: return [nums]
    
    for i in nums:
        s = nums[:]
        s.remove(i)
        for y in generate(s):
            if [i]+y not in res:
                res.append([i]+y)
    return res

x = generate([1, 2, 3])

79. 单词搜索

class Solution(object):
    def exist(self, board, word):
        for i in range(len(board)):
            for j in range(len(board[0])):
                pos_l = []
                if board[i][j] == word[0]:
                    pos_l.append([i, j])
                    if self.search(board, i, j, 1, word, pos_l):
                        return True
        return False

    def search(self, board, i, j, pos, word, pos_l):
        #print(i, j, pos)
        if pos == len(word):
            return True
        if i-1 >= 0 and [i-1, j] not in pos_l and board[i-1][j] == word[pos]:
            pos_l.append([i-1, j])
            if self.search(board, i-1, j, pos+1, word, pos_l):
                return True
            else: pos_l.pop(-1)
        if i+1<len(board) and [i+1, j] not in pos_l and board[i+1][j] == word[pos]:
            pos_l.append([i+1, j])
            if self.search(board, i+1, j, pos+1, word, pos_l):
                return True
            else: pos_l.pop(-1)
        if j-1 >= 0 and [i, j-1] not in pos_l and board[i][j-1] == word[pos]:
            pos_l.append([i, j-1])
            if self.search(board, i, j-1, pos+1, word, pos_l):
                return True
            else: pos_l.pop(-1)
        if j+1<len(board[0]) and [i, j+1] not in pos_l and board[i][j+1] == word[pos]:
            pos_l.append([i, j+1])
            if self.search(board, i, j+1, pos+1, word, pos_l):
                return True
            else: pos_l.pop(-1)
        return False