tyler的博客

题目：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回null。思路：（1）假设链表有a+b个结点（从head到链表环入口共a个结点，链表环共b个结点）；（2）设快、慢指针分别走了f、s步，那么会有以下两个结论：f=2*sf=s+n*>b<----快指针多走了n个环的长度；（3）由（2）可得，s=n*b；（4）再假设，我们从head指针开始，一直走到环的入口，共走了k步，那么k=a+n*b，此时由于慢指针slow已经走了n*b步（s=.

解题思路参考链接https://leetcode-cn.com/problems/the-number-of-good-subsets/solution/py3-by-mao1112-sxmx/，我在此基础上添加了自己的理解。"""解题思路：找出所有数字的组合，【每种组合的次数=各数字次数的成绩】注意：限制数字<=30，考虑暴力解。"""import collectionsclass Solution: def numberOfGoodSubsets(self, nu.

力扣-560. 和为 K 的子数组参考自：https://leetcode-cn.com/problems/subarray-sum-equals-k/solution/he-wei-kde-zi-shu-zu-by-leetcode-solution/class Solution1: def subarraySum(self, nums, k): res = 0 n = len(nums) # 暴力解-相当于三重循环 for .

class Solution: def generateParenthesis(self, n: int) -> List[str]: # 特点：当前某个组合中，右括号的数量一定比左括号少 # 利用回溯算法 left_p = ["(" for _ in range(n)] right_p = [")" for _ in range(n)] # print(left_p, right_p) sel

# 超时class Solution: def canJump(self, nums: List[int]) -> bool: # 回溯+贪心算法 if len(nums) == 1: return True self.flag = 0 self.backtrack(0, nums[:]) if self.flag == 1: return True

回溯算法–超时class Solution: def getPermutation(self, n: int, k: int) -> str: self.res = {} cur = "" nums = [str(i) for i in range(1, n+1)] self.pos = 0 # print(nums) self.backtrack(nums[:], cur).

'''采用了一种比较麻烦的方法：先通过双重循环找到第一个数字和第二个数字，然后循环计算后边的value。'''class Solution: def isAdditiveNumber(self, num: str) -> bool: nums = [n for n in num] self.res = False # 第一个数肯定在字符串的前1/2，通过记录数字的位置，来计算数字和 # 最重要的是确定第一

class Solution: def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: self.res = [] candidates = sorted(candidates) self.n = len(candidates) self.backtrack([],0,0, target, candidates[:])

# 使用回溯算法class Solution: def exist(self, board: List[List[str]], word: str) -> bool: # 有个二维列表记录当前位置是否走过 # 记录走过的路径，如果word在走过的路径中，则返回true self.res = False # m * n 的矩阵 m = len(board) n = len(board[0])

class Solution: def permute(self, nums: List[int]) -> List[List[int]]: self.res = [] choice = nums[:] # print(choice) self.drawback(0, nums[:], choice) return self.res def drawback(self, i, nums, choice)

'''自己的想法，超时'''class Solution: def coinChange(self, coins: List[int], amount: int) -> int: # 动态规划 dp = [1 for i in range(len(coins))] # 最简单的状态 # if amount == 0: # return 0 # dp[amount] = num

# 自己的想法，超时# 层次遍历，记录每一层的最左节点和最右节点位置class Solution: def widthOfBinaryTree(self, root: TreeNode) -> int: # if not root: # return 0 # 层次遍历 queue = collections.deque() queue.append(root) max_v = 0

参考自https://leetcode-cn.com/problems/path-sum-iii/solution/qian-zhui-he-di-gui-hui-su-by-shi-huo-de-xia-tian/前缀和–是指到达当前元素的路径之前所有元素的和在同一个路径之下，如果两个数的前缀和是相同的，那么这些节点之间的元素总和为零那么，在同一个路径之下，在节点A的前缀和与节点B的前缀和相差target，则位于节点A和节点B之间的元素之和是target。（如当前已知路径为A->C-&gt.

# 利用并查集class Solution: def findRedundantConnection(self, edges: List[List[int]]) -> List[int]: n = len(edges) parent = list(range(n+1)) def find(index): # 找到当前节点index的父节点 if parent[index]==index:

# 双重循环，会超时class Solution: def longestPalindrome(self, s: str) -> str: n = len(s) dp = [[False] * n for _ in range(n)] # 注意定义二维列表的方法 ans = "" # 枚举子串的长度，从0开始 for l in range(n): # 枚举子串的起始位置 i，这样可以通过

class Solution: def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': if root is None: return None path = [] path_dict = {} # 记录当前点经历过的路径，重点 def PreOrder(roo

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def hasPathSum(self, root: TreeNode, sum: int) -> bool: if roo

# 层次遍历class Solution: def minDepth(self, root: TreeNode) -> int: if root is None: return 0 queue = [] layer = [] cur = root queue.append(cur) layer.append(1) min_layer =

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNo

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None# 解法一：前序遍历，记录每层从左到右的节点，然后进行翻转class Solution: def zigzagLevelOrder(self, root: TreeNode) -

一开始打算利用递归遍历（根->左->右）和（根->右->左）结果是否相同来判断一颗二叉树是否是对称二叉树，但是一直存在漏洞；之后尝试结合三种遍历中的两种来做，发现仍然有漏洞。最后想到的办法是将空节点也加入到结果列表中，成功解决。# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left.

# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = right''' 第100题'''class Solution: def isSameTree(self, p: TreeN

''' 第94题'''# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution: # 递归 def inorderTraversal(se

# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None# 解题关键--使用字典，记录每一层的节点； #前序遍历的方法class Solution: def levelOrder(self, root: TreeNode) -