明明的博客

题目地址：https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/我的解答：class Solution: def findDisappearedNumbers(self, nums: List[int]) -> List[int]: if not nums: return [] n = len(nums) res = [] nums

题目地址：https://leetcode-cn.com/problems/invert-binary-tree/看了百十来题，我仍然是一看就会，一做就废的菜鸡（有时候看都看不懂# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Nonec

题目地址：https://leetcode-cn.com/problems/house-robber/动态规划，即使这么简单我还是写不对注意：只要不进两个连续的房屋就不会报警，但是可以跨好几个房屋，只要它们屋里的现金相加结果最大dp[n]表示前n个房屋能偷到的最大现金，那dp[n + 1] 就等于 dp[n - 1] + 第n + 1这个房屋里的现金num，和dp[n]这两个数中的最大值，即：dp[n + 1] = max(dp[n], dp[n- 1] + num)class Solution:

题目地址：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/注意：如果两个链表没有交点，返回 null.在返回结果后，两个链表仍须保持原有的结构。可假定整个链表结构中没有循环。程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。解法1：# Definition for singly-linked list.# class ListNode:# def __init__(self, x)

题目地址：https://leetcode-cn.com/problems/combination-sum-ii/class Solution: def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: if not candidates: return [] n = len(candidates) candidates.sort()

题目地址：https://leetcode-cn.com/problems/combination-sum/提示： 1 <= candidates.length <= 30 1 <= candidates[i] <= 200 candidate中的每个元素都是独一无二的。 1 <= target <= 500class Solution: def combinationSum(self, candidates: List[int], target: i

题目地址：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/labuladong二分法笔记之前看负雪明烛推荐过labuladong，我就找了他的算法小抄（是叫这名儿吧？）来看，也关注了公众号。觉得这篇写得很好，我读完之后的笔记如下：一般要求时间复杂度为O(logN)的题目就要考虑二分法。二分法主要是解决在有序数组中搜索一个值、搜索左边界/右边界的问题。1.搜索一个值的

题目地址：https://leetcode-cn.com/problems/linked-list-cycle/时间复杂度和空间复杂度都是O(n)：# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def hasCycle(self, head:

题目地址：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/class Solution: def search(self, nums: List[int], target: int) -> int: if not nums: return -1 l, r = 0, len(nums) - 1 while l < r: mid = (

题目地址：LeetCode#31.下一个排列class Solution: def nextPermutation(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ if len(nums) < 2: return nums for i in range(len(nu

我要什么时候才能达到那种看一个题就知道用什么方法、套什么模板的境界呢class Solution: def generateParenthesis(self, n: int) -> List[str]: #if n == 0: return [] res = [] path = "" self.dfs(res, n, n, path) return res def dfs(self, res, lef.

每日回顾六题—07-07—#69 有点儿问题#70可#83 还要再写#88 再写#94 ok#98 再做做午休

从今天开始往后的几天，我打算对这一个半月以来做的题做一个回顾和总结。相信好些题目我已经忘记了！所以我的计划是：重新做一遍。查缺补漏，记录于此。#1可#2#3#4 hard#5#6思路有，写不出来#7#8考正则表达式#9 回文数#10 hard 略过#11 可今天上午学了个寂寞，真是伤心，我可真是菜到头了。。 —2020-06-28—...

我做不出来这就是#112的升级，但我就是不会转弯呀看别人题解，看半天算是懂了，尤其是tmp + [root.val]这个写法# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def pat.

1、递归#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 not root: return False sum -= root.val if not root.left and not ro.

BFS比DFS合适，因为BFS遇到第一个叶子结点就可直接返回结果，而DFS要遍历整棵树我再写一遍递归和BFS：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def minDep.

这个题对我来说好绕啊，我懂思路但是递归真难理解。。。看题解看半天还是有点懵，我晕！# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isBalanced(self, root: Tr.

一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。二叉搜索树：任一节点的值都大于其左子树的节点值，都小于其右子树的节点值。把链表转成数组，就和前一题一样辽：# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = None# Definition for a bin

BFS，令中间位置右边元素（如果数组长度为偶数；数组长度为奇数则就是中间位置元素）作为根节点# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def sortedArrayToBST(self.

这就是#102变个形式输出# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def levelOrderBottom(self, root: TreeNode) -> List[List.

和#105 一个解法：# 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, inorder: List[int], postorder: List[int].

前序的第一个节点就是根节点，再去中序里面找到根节点的索引，那根节点之前的部分就是左子树，根节点后部分就是右子树找索引用哈希表，降低时间复杂度# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: .

这个题目是#102变了个输出形式而已，巩固一下# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def zigzagLevelOrder(self, root: TreeNode) ->.

我用的递归，以为没问题，结果提交之后没通过！仔细阅读才发现，题目我都没完全理解：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。比如：[10,5,15,null,null,6,20] 这个测试用例结果应该返回false，因为右子树中的左子节点6小于根节点10我好傻呀以下是看了题解之后再写的正解：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x.

对题解区的各解法做一个总结：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None#前序（根左右）class Solution: def inorderTraversal(self, root: TreeNode) .

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

重点是你的算法应该具有线性时间复杂度。这类题用位运算，异或（相同为0，不同为1，满足交换律和结合律）1 ^ 1 = 00 ^ 0 = 01 ^ 0 = 1Class Solutions: def singleNumber(self, nums: List[int]) -> int: res = nums[0] for i in range(len(nums)): res ^= nums[i] return resget新知识...

递归（dfs）：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def maxDepth(self, root: TreeNode) -> int: if not ro.

两种解法，递归（dfs）和队列（广度）递归，看了官方题解：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isSymmetric(self, root: TreeNode) -&g.

这类题非常陌生，不过有好多个类似题可以用来反复练习，从这开始# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isSameTree(self, p: TreeNode, q: Tree.

进阶：你可以优化你的算法到 O(k) 空间复杂度吗？class Solution: def getRow(self, rowIndex: int) -> List[int]: if rowIndex == 0:return [1] L = [1] L1 = [0] + L L2 = L + [0] #temp = [] n = 0 while(n..

这个题目，在廖雪峰的Python教程里我看到过，是生成器那一节，我记得当时我还写了点笔记，但是这次虽然做出来了可是不是用生成器，还花了好一会儿时间！class Solution: def generate(self, numRows: int) -> List[List[int]]: if numRows == 0:return [] res = [[1]] if numRows == 1:return res l = [0].

Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。str = 'hello'print(str.zfill(10))#输出 00000helloclass Solution: def addBinary(self, a: str, b: str) -> str: n = max(len(a),len(b)) a = a.zfill(n) b = b.zfill(n) c = 0 #c.

递归、动态规划、斐波那契数列公式三种解递归容易超时、直接动态规划空间复杂度为O（n），优化一下可以为O（1）：class Solution: def climbStairs(self, n: int) -> int: if n == 1:return 1 if n == 2:return 2 a,b,res = 1,2,0 for i in range(3,n+1): res = a+b .

二分法：class Solution: def mySqrt(self, x: int) -> int: if x == 0:return 0 l,r = 0,x while(l<=r): mid = (l+r) // 2 if mid*mid == x: return mid elif mid*mid < x: .

我思路是合并后排序，以下是我的解法，通过了但其实是不符合题目要求的，因为题目说了只能在nums1本身做修改class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ .

这个题目似曾相识# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def deleteDuplicates(self, head: ListNode) -> ListNode: dummy = ListNode(0) .

一开始我想的是直接操作，判断、加一或者进位加一，但我写着写着发现这样要处理好几种特殊情况太，譬如3999、99 有点麻烦。于是我换了种思路：把列表转成字符串再转成整型，加一之后再转成整型列表：class Solution: def plusOne(self, digits: List[int]) -> List[int]: s = ''.join(map(str,digits)) intd = int(s) + 1 return [int(.

我的解：class Solution: def lengthOfLastWord(self, s: str) -> int: if not s:return 0 if ' ' not in s:return len(s) if s.replace(' ','') == '':return 0 s = s.rstrip(' ') res = 0 for i in s[::-1]: .

动态规划class Solution: def maxSubArray(self, nums: List[int]) -> int: if not nums:return 0 if len(nums) == 1:return nums[0] max_sum = nums[0] for i in range(1,len(nums)): nums[i] = max(nums[i],nums[i]+nums.