2021年01月_qq_40707462

原创 leetcode【中等】300、最长上升子序列

思路：动态规划dp[i]定义为，到第i个位置为止的，最长递增子序列，每遍历到一个i，就用j从0遍历到i-1，选出每个比i小的j，即当前数i可以接在前面哪个序列的尾巴上，计算最大长度初始：dp都为1，每个数都是一个子序列转移方程： dp[i] = max(dp[i], dp[j] + 1) for j in [0, i)答案：max(dp)class Solution: def lengthOfLIS(self, nums: List[int]) -> int: if.

2021-01-28 17:42:36 187

原创 leetcode【中等】64、最小路径和

思路：动态规划当 i>0 且 j=0时，dp[i][0]=dp[i-1][0]+grid[i][0]当 i=0 且 j>0时，dp[0][j]=dp[0][j-1]+grid[0][j]当 i>0 且 j>0 时，dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j]class Solution: def minPathSum(self, grid: List[List[int]]) -> int: .

2021-01-28 16:06:46 85

原创 leetcode【中等】144、二叉树的前序遍历

思路：参考# 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 preorderTraversal(self, root: Tr.

2021-01-26 16:27:02 48

原创 leetcode【中等】94、144、145二叉树的中序、前序、后序遍历

思路：一直向左遍历，直到最后一层最左边，打印当前，转向右边递归过程：inorder(root.left) inorder(root.left) inorder(root.left) 为null返回打印节点 inorder(root.right) inorder(root.left) inorder(root.left) ........# Definition for a binary tree node.# class TreeNode:# .

2021-01-26 15:17:29 120

原创 leetcode【中等】102、二叉树的层序遍历

思路：BFS普通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, roo.

2021-01-26 14:49:14 102

原创 leetcode模板整理

1、DFS\BFS遍历树def dfs(root): if (root is None): return dfs(root.left) dfs(root.right)def bfs(root):#相当于层序遍历 queue=[] queue.append(root); while (queue): node = queue.pop(0)#弹出一个节点，然后挨个添加它的左右子树

2021-01-26 14:44:55 363

原创 leetcode【剑指offer】45、把数组排成最小的数

思路一：将数字转换成字符串，然后自定义大小比较机制进行快排对于str自定义规则：若字符串x+y>y+x，则下x>yclass Solution: def minNumber(self, nums: List[int]) -> str: def fast_sort(l , r): if l >= r: return i, j = l, r .

2021-01-22 23:59:32 411

原创 leetcode【困难】42、接雨水

思路：遍历得到当前墙，如果比前一个墙高，加上与前一个墙之间的体积，并接着向前遍历，如果之前有比前一个墙更高的（比当前墙低），再算上增加的体积，最后弹出所有比当前墙低的，以后也不会用上了注意：每遍历一个墙，要维护一个bottom，接满水的部分就相当于底部升高class Solution: def trap(self, height: List[int]) -> int: ans = 0 stack = [] # 记录遍历过的矮墙 for .

2021-01-22 14:33:04 132 1

原创 leetcode【中等】113、路径总和2

思路：DFS# 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 pathSum(self, root: TreeNode, ta.

2021-01-19 17:46:45 92

原创 leetcode【中等】112、113、437、路径总和123

思路一：DFS如果为叶子节点且总和为target，返回True，否则递归接着遍历# 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: d.

2021-01-19 16:46:41 176

原创 leetcode【简单】69、x的平方根

class Solution: def mySqrt(self, x: int) -> int: return self.find(0,x,x) def find(self,left,right,target): if target==0 or target==1: return target while left<right: mid = left + (right - .

2021-01-19 15:09:09 105

原创 leetcode【中等】54、螺旋矩阵

思路：定义表示四条边的变量l,r,t,b表示左右上下按照顺序遍历上右下左四条边，每遍历一条边该范围缩小1，比如上边遍历完，则t减一。定义一个计数变量num,当num等于所有元素数量之和则跳出循环注意有可能在循环结束前已经超过了范围，所以在遍历四条边时候，也要加上条件num <= totalclass Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: l=0 .

2021-01-19 14:41:14 88

原创 leetcode【简单】121、买股票的最佳时机

思路：动态规划/双指针及其优化写法i用来遍历，minprice记录目前最小值，每遍历一个数记录一会利润，保存最大的profit可以看作双指针i和minprice，i不停移动，minprice保持在最小位置import mathclass Solution: def maxProfit(self, prices: List[int]) -> int: profit=0 minprice=math.inf for i in pri.

2021-01-18 17:31:24 99

原创 leetcode【中等】22、括号生成

思路一：递归/动态规划考虑 i=n 时相比 n-1 组括号增加的那一组括号的位置。"(" + 【i=p时所有括号的排列组合】 + ")" + 【i=q时所有括号的排列组合】p + q = n-1，且 p q 均为非负整数。当上述 p 从 0 取到 n-1，q 从 n-1 取到 0 后，所有情况就遍历完了。class Solution: def generateParenthesis(self, n: int) -> List[str]: if n==0: .

2021-01-18 16:03:07 148

原创 JavaGuide面试突击版笔记

一、java基础1、面向对象易维护、复用、扩展，但性能比面向对象低。Java性能低的主要原因不是因为面向对象，而是因为它是半编译语言，不是被CPU直接执行的二进制码2、Java特点面向对象（封装、继承、多态）、平台无关（虚拟机）、安全可靠、多线程、编译与解释并存、支持网络编程3、JVM JDK JREJVM 有针对不同系统的特定实现（Windows，Linux， macOS），⽬的是使⽤相同的字节码，它们都会给出相同的结果。JDK 是 Java Development Kit，它是功能⻬全的

2021-01-13 17:23:19 471

原创 leetcode【中等】62、不同路径

思路一：排列组合class Solution: def uniquePaths(self, m: int, n: int) -> int: #排列组合，一共走m+n-2步，选出m-1条横的 def f(n): if n<2: return 1 res=1 for i in range (1,n+1):#注意i=5停止 .

2021-01-12 17:20:37 96

原创 leetcode【简单】53、最大子序和

思路：如果sum<0，那无论后面加上什么，都比不要之前的sum要小，所以直接扔点，去和ans比较如果sum>0，那加上后面一个数，再和ans比较class Solution: def maxSubArray(self, nums: List[int]) -> int: ans=nums[0] sum=0 for i in range(len(nums)): if sum>0: .

2021-01-10 20:52:30 91

原创 leetcode【中等】5、最长回文子串 / 647、回文子串 / 516、最长回文子序列

思路一：暴力（超时）用一个函数专门判断是否是回文，然后枚举所有子串，不断更新max_len复杂度n^3，双循环n*n，判断回文nclass Solution: # 暴力匹配（超时） def longestPalindrome(self, s: str) -> str: # 特判 size = len(s) if size < 2: return s max_len = 1 .

2021-01-10 20:29:42 192

原创 leetcode【中等】34、在排序数组中查找元素的第一个和最后一个位置

思路：要求复杂度nlogn，直接遍历复杂度是n，要用二分查找注意边界上下取整！class Solution: def searchRange(self, nums: List[int], target: int) -> List[int]: if len(nums)==0: return [-1,-1] l=self.findleft(nums,target) if l==-1: retur.

2021-01-10 19:02:13 151

原创 leetcode【简单】226、翻转二叉树

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

2021-01-10 16:50:03 65

原创 leetcode【简单】104、二叉树的最大深度 / 110、平衡二叉树 / 543、二叉树的直径

思路：递归# 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 maxDepth(self, root: TreeNode) -.

2021-01-09 22:41:30 104 1

原创树与简单的递归（dfs）101、104、559、110、543、226、236、235、563、617、剑指26、面试题 04.10

思路一：递归# 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) -> bool: def che.

2021-01-09 22:22:20 154

原创 leetcode【简单】21、合并两个有序链表

思路一：递归# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: i.

2021-01-09 21:56:42 220

原创 leetcode【中等】347、前K个高频元素

注意：复杂度优于nlohn，快速排序的复杂度等于nlohn思路和215类似：维护一个大小为k的小顶堆，复杂度nlogk创建一个k大小的小根堆；堆满后，若新加的数大于堆首数，弹出堆首元素 – 弹出了m-k个最小的import heapqclass Solution: def topKFrequent(self, nums: List[int], k: int) -> List[int]: hash = {} for i in nums: .

2021-01-09 17:54:33 92

原创 leetcode【中等】215、数组中的第K个最大元素

思路一：暴力时间复杂度：O(NlogN)，算法的性能消耗主要在排序，默认使用快速排序，因此时间复杂度为O(NlogN)。空间复杂度：O(1)，这里是原地排序，没有借助额外的辅助空间。class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: nums.sort() return (nums[len(nums)-k])思路二：小顶堆，比暴力解法稍快使用容量为.

2021-01-09 16:38:28 103

原创 leetcode【简单】155、最小栈

思路：用额外的列表空间min_stack储存最小值，每进一个值，min_stack里也进一个此时的最小值class MinStack: def __init__(self): """ initialize your data structure here. """ self.stack=[] self.min_stack=[math.inf] def push(self, x: int) -> No.

2021-01-08 22:47:44 88

原创 leetcode【中等】20、有效的括号 / 678、有效的括号字符串

思路：栈遇到左括号添加栈（list），遇到右括号在栈里寻找最近的符号看是否匹配，不匹配就false（最近的不匹配那肯定闭合顺序不对）class Solution: def isValid(self, s: str) -> bool: if len(s) % 2 == 1: return False pairs = { ")": "(", "]": "[", ..

2021-01-08 22:24:22 130

原创 leetcode【中等】581、最短无序连续子数组

思路一：排序排序后的数组为【有序部分】+ 【无序部分】+【有序部分】，将新旧数组分别从前后比较，即可知道中间无序的长度注意：①新数组不能直接“=”，不然排序后新旧都排了，要“新=旧.copy”②注意如果旧数组本来就有序，要特判，不能再r-lclass Solution: def findUnsortedSubarray(self, nums: List[int]) -> int: new=nums.copy()#不能直接等于 new.sort() .

2021-01-08 17:29:19 105

原创 leetcode【中等】78、子集 / 90、子集2

思路1：迭代对于[1,2,3]①初始化res=[ [ ] ]，即添加了一个空集②对于1，res=[ ]+[ [1]+[ ] ]=[ [ ],[1] ]③对于2，res=[ [ ],[1] ]+[ [2]+[ ] ]=[ [ ],[1] ,[2] ]res=[ [ ],[1] ,[2] ]+[ [2]+[1] ]=[ [ ],[1] ,[2],[2,1] ]…class Solution: def subsets(self, nums: List[int]) -> List[Li.

2021-01-07 16:22:59 133

原创 leetcode【简单】7、整数反转

注意：溢出和正负号思路一：常规class Solution: def reverse(self, x: int) -> int: res=0 y=abs(x) while y!=0: a=y%10 res=res*10+a y=int(y/10) if res<-2**31 or res>2**31-1: .

2021-01-06 17:12:15 82

原创 leetcode【中等】6、Z字形变换

思路：字符串先a[0],a[1],a[2]…正序填入数组，到a[numRows-1]再倒叙排class Solution: def convert(self, s: str, numRows: int) -> str: if numRows<2: return s a=[''for _ in range(numRows)]#先置空，不然后面会超出索引范围 i=0#行号，0~numRows-1 ..

2021-01-06 16:22:47 88

原创 leetcode【中等】56、合并区间 / 435、无重叠区间 / 452、用最少数量的箭引爆气球

思路：①先按数组左端点排序②如果后一个数组的左端点大于前一个数组的右端点，则不重合，直接添加到result③若重合，则将前一个数组的右端点替换为前后两个数组右端点中较大的一个class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]: intervals.sort(key=lambda x: x[0]) result=[] for n in.

2021-01-06 15:17:40 120

原创 leetcode【简单】202、快乐数

解析：如果平方和陷入循环，那永远不可能为1，即判断是否成环就可以思路一：暴力class Solution: def isHappy(self, n: int) -> bool: def get_sum(n): sum=0 while(n>0): m=n%10 n=int(n/10) sum=sum+m*m .

2021-01-05 16:15:44 66

原创 leetcode【简单】141、环形链表/142、环形链表的入口 / 287、寻找重复数

题目：给定一个链表，判断链表中是否有环。思路1：暴力# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def hasCycle(self, head: ListNode) -> bool: hash=[] w

2021-01-05 15:30:23 183 1

空空如也

启动springboot，localhost无法访问

matlab 使用cvx出现Cannot perform the operation: {convex} ./ {convex}

使用pygame为什么总是闪退？

图像分类OpenCV中svm使用报错

Python爬取小说 有些章节爬得到有些爬不到 分别爬取都是可以的

Python爬取文本写入CSV，用replace替换br标签后，每个字后面都会换行？

Python爬取小说有些章节爬得到有些爬不到分别爬取都是可以的