leetcode-top100回溯算法

最新推荐文章于 2024-07-06 07:33:24 发布

杜阿福

最新推荐文章于 2024-07-06 07:33:24 发布

阅读量393

点赞数 6

文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/weixin_53908842/article/details/136137630

版权

组合总和

题目链接

39. 组合总和 - 力扣（LeetCode）

解题代码

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        def dfs(candidates,begin,size,path,res,target):
            if target < 0:
                return
            if target == 0:
                res.append(path)
                return
            
            for index in range(begin,size):
                dfs(candidates,index,size,path + [candidates[index]],res,target - candidates[index])

        size = len(candidates)
        if size == 0:
            return []
        path = []
        res = []
        dfs(candidates,0,size,path,res,target)

        return res

括号生成

题目链接

22. 括号生成 - 力扣（LeetCode）

解题代码

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        if n == 0 :
            return []
        def generate(A):
            if len(A) == 2*n:
                if valid(A):
                    ans.append("".join(A))
            else:
                A.append("(")
                generate(A)
                A.pop()
                A.append(")")
                generate(A)
                A.pop()
        def valid(A):
            bal = 0
            for c in A:
                if c == '(': bal += 1
                else: bal -= 1
                if bal < 0: return False
            return bal == 0
        ans = []
        generate([])
        return ans

单词搜索

题目链接

79. 单词搜索 - 力扣（LeetCode）

解题代码

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        directions = [(1,0),(-1,0),(0,1),(0,-1)]
        def check(i: int, j:int, k:int) ->bool:
            if board[i][j] != word[k]:
                return False
            if k == len(word) - 1:
                return True
            
            visited.add((i,j))
            result = False
            for di,dj in directions:
                newi, newj = i + di,j + dj
                if 0 <= newi < len(board) and 0 <= newj < len(board[0]):
                    if (newi,newj) not in visited:
                        if check(newi,newj,k + 1):
                            result = True
                            break
            visited.remove((i,j))
            return result
        h,w = len(board),len(board[0])
        visited = set()
        for i in range(h):
            for j in range(w):
                if check(i,j,0):
                    return True
        return False

分割回文串

题目链接

131. 分割回文串 - 力扣（LeetCode）

解题代码

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        n = len(s)
        f = [[True] * n for _ in range(n)]

        for i in range(n - 1, -1, -1):
            for j in range(i + 1, n):
                f[i][j] = (s[i] == s[j]) and f[i+1][j-1]

        ret = list()
        ans = list()

        def dfs(i:int):
            if i == n:
                ret.append(ans[:])
                return
        
            for j in range(i,n):
                if f[i][j]:
                    ans.append(s[i:j + 1])
                    dfs(j + 1)
                    ans.pop()
        dfs(0)
        return ret

N皇后

题目链接

51. N 皇后 - 力扣（LeetCode）

解题代码

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        def generateBoard():
            board = list()
            for i in range(n):
                row[queens[i]] = "Q"
                board.append("".join(row))
                row[queens[i]] = "."
            return board

        def backtrack(row: int):
            if row == n:
                board = generateBoard()
                solutions.append(board)
            else:
                for i in range(n):
                    if i in columns or row - i in diagonal1 or row + i in diagonal2:
                        continue
                    queens[row] = i
                    columns.add(i)
                    diagonal1.add(row - i)
                    diagonal2.add(row + i)
                    backtrack(row + 1)
                    columns.remove(i)
                    diagonal1.remove(row - i)
                    diagonal2.remove(row + i)
                    
        solutions = list()
        queens = [-1] * n
        columns = set()
        diagonal1 = set()
        diagonal2 = set()
        row = ["."] * n
        backtrack(0)
        return solutions