sabrinalx的博客

题目描述：给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。解题思路：转化为背包问题，代码如下class Solution: def canPartition(self, nums: List[int]) -> bool: total = sum(nums) size = len(nums) if size <= 1: return False if total % 2: ret

题目描述：给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务，或者在待命状态。然而，两个相同种类的任务之间必须有长度为 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。你需要计算完成所有任务所需要的最短时间。解题思路：找到出现次数最多的任务，假设为A，首先安排A， 然后在执行

题目描述：给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:1.你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。2.卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。解题思路：根据题目描述，每天结束会有三种不同状态（1）持有股票（2）不持有股票，而且第二天是冷冻期（3）不持有股票，第二天不是冷冻期，可以根据每天的三种状态之间的转换完成状态转移，代码如下：cl

题目描述：给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。解题思路：滑动窗口，维护两个指针记录各个字母出现的次数，代码如下：class Solution: def findAnagrams(self, s: str, p: str) -> List[int]: size = len(s) sizep = len(p)

题目描述：给定一个无序的整数数组，找到其中最长上升子序列的长度。解题思路：动态规划，找到以每个元素结尾的最长上升子序列，当前位置的最长上升子序列为，在当前位置之前并且小于当前值的最长上升子序列加上1，如果不存在等只有自身，代码如下：class Solution: def lengthOfLIS(self, nums: List[int]) -> int: size = len(nums) if size == 0: return 0 ans

题目描述：给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。思路详解：（1）暴利解法，遍历所有可能的连续子数组（2）用哈希表记录从左到右累积的和出现的次数，包含当前位置的满足条件的连续子数组的数量就是以当前的累积和减去K为值的累积和出现的次数解法一代码如下，会超时class Solution: def subarraySum(self, nums: List[int], k: int) -> int: res = 0 siz

题目描述：给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。解题思路：递归调用，如果一个是None，就直接返回另一个，否则将右边的值加到左边上，然后递归调用处理左边的子树和右边的子树，代码如下：# Definition for a binary tree node.# class TreeNode:#

题目描述：给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。解题思路：现将二叉搜索树按照中序进行遍历，然后对中序遍历的节点进行倒叙遍历，连续将后一个值累加到前一个值上，就完成了最后的节点值是当前值加上比自己大的节点值之和，代码如下：# Definition for a binary tree node.# class TreeNode:# def __init__(self,

题目描述：给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。解题思路：递归法，递归调用函数返回当前节点的直线连接(没有任何两个点是在同一层的)的路径最大值和总的路径最大值，当前节点的路径长度最大值等于左子树的最大值、右子树的最大值和左边直线路径最大值+右边直线路径最大值+2，这三个中值最大的一个，代码如下：# Definition for a binary tree node.# class TreeNode:#

题目描述：给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。你找到的子数组应是最短的，请输出它的长度。解题思路：对数组进行排序，然后第一个不一样的和最后一个不一样的区间就是要找的最短子数组,代码如下：class Solution: def findUnsortedSubarray(self, nums: List[int]) -> int: size = len(nums) if size == 1:

题目描述：给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i，计算其二进制数中的 1 的数目并将它们作为数组返回。解题思路：以2的幂次方为循环，如果当前数大于等于2的i次方，小于2的(i+1)次方，当前的1的个数就是1+当前的数减去2的i次方的数的1的个数，即ans[num] = ans[num %(2^int(lognum))]+1,代码如下：class Solution: def countBits(self, num: int) -> List[int]:

题目描述：给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。解题思路：先从左到右遍历，将每个位置左边的数累乘，再从右到左将每个位置的右边的数累乘上左边的累乘就得到除自身之外其他所有数的积了。代码如下：class Solution: def productExceptSelf(self, nums: List[int]) -> List[int]:

题目：编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：1.每行的元素从左到右升序排列。2.每列的元素从上到下升序排列。解题思路：因为元素具有的大小特性，可以从左下角往右上角搜索，如果当前元素等于target直接返回，如果当前元素大于target，那么当前行的右边元素都可以排除掉，如果当前元素小于target，那么当前列的上边元素可以直接排除掉，代码如下：class Solution: def searchMatrix(self, m

解题思路:动态规划，要求能组成amount的硬币的最少数量，先求出组成0~amount-1的硬币数量，amount的结果由amount-硬币的面值转化而来class Solution: def coinChange(self, coins: List[int], amount: int) -> int: if amount == 0: return 0 dp = [float(inf)] * (amount + 1) dp[0] = 0

思路一:求解长度为n的区间内连续子数组的最大乘积，可以先求解前n-1个数组成的数组内的连续子数组的最大乘积，再考虑由第n个数组成的连续子数组中的乘积和前n-1个乘积中更大的，作为最终结果，代码如下：class Solution: def maxProduct(self, nums: List[int]) -> int: size = len(nums) res = [0] * size res[0] = nums[0] for

解题思路：将戳气球的过程倒过来思考，每次插入一个气球可以获的对应的硬币，考虑将所有气球填满，就是可以获得的全部硬币。令solve(i,j)为填满开区间(i,j)可以获得的最大硬币数，遍历(i,j)内部的所有可能的位置mid，令mid为提一个插入的气球，这个操作可以获得的奖励为val[i]*val[mid]*val[j]，再加上区间(i,m)和(m,j)区间可以获得的奖励，就是区间(i,j)之间可以获得的奖励，取三个奖励之和的最大值记为solve(i,j)，代码如下：class Solution:

解题思路：https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/bfsjian-dan-er-you-xiang-xi-de-pythonjiang-jie-by-/代码如下：class Solution: def removeInvalidParentheses(self, s: str) -> List[str]: def isValid(s): count =

解题思路：用一个队列维护滑动窗口中可能会成为最大值的索引，当前值如果小于前一个值，那在后面窗口依然可能成为最大值，但是如果当前值大于之前的值，那前面的值肯定在后面的窗口中不会成为最大值，那就可以直接删去，还需要注意的就是要随时更新左边界，如果超出窗口范围就要及时删除class Solution: def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]: if k == 0: return []

解题思路：一开始想在先序遍历的过程中就完成链表的转变，实现的时候有点麻烦，就先将二叉树先序遍历的节点保存下来，然后最后再一起修改为链表# 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 = ri

解题思路：（1）先遍历链表用数组保存，再按住val值进行排序，在重新构造为链表返回（2）直接对链表进行归并排序解法一：排序算法用内置函数sort()# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def sortList(self, head:

解题思路：当前节点能够偷到钱之和祖孙三代有关，即爷爷偷到的钱+四个孙子的前vs两个儿子偷到的钱解法一：递归，最后两个case会超时# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def ro

解题思路：对高个子来说矮个子是看不见的，所以（1）对数组按身高的降序排列，相等身高按k值的升序排列（2）依次将排序好的元素按照k值放到返回数组对应的index上，当矮个子的k值和高个子的k值相等时，直接插入到对应的index，高个子的直接后移class Solution: def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]: def cmp(p1, p2): if

解题思路：先求出到两个节点的所经过的路径，然后从根节点找重复的最长路径，重复最长路径的最后一个节点就是最近公共祖先# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def lowestCommo

解题思路：双指针，最开始两个指针一个指向最左边，一个指向最右边，两个指针代表可以构成矩形的左右边界，可以形成的矩形面积为两个指针指向的高度中较小的一个乘以两个指针之间的距离，每次移动一个指针，哪个指针指向的高度更小就移动对应的指针。class Solution: def maxArea(self, height: List[int]) -> int: res = 0 size = len(height) i, j = 0, size-1

解题思路：快排，找到第k大的就停止class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: def partition(left, right): pivot = nums[left] i,j = left, right while(i < j): while(i < j

解题思路：用indexes储存以当前字符为右边界可以构成回文串的左边界，后面的回文串可以建立前面的回文串之上，代码如下class Solution: def countSubstrings(self, s: str) -> int: indexes = [0] size = len(s) if size == 0: return 0 if size == 1: return 1 res = 1 f

解题思路：把这个问题理解为对矩阵的每一行都求第84题柱状图中的最大矩形，其中最大的就是最终结果class Solution: def maximalRectangle(self, matrix: List[List[str]]) -> int: rows = len(matrix) if rows == 0: return 0 cols = len(matrix[0]) if cols == 0: return 0

解题思路：将数组的字符串的每个字符排序后的元组作为key,将key相同的字符串都放在一个数组中，key相同的字符串即字母异位的单词class Solution: def groupAnagrams(self, strs: List[str]) -> List[List[str]]: visited = {} for x in strs: s = tuple(sorted(x)) if s not in visit

解题思路：递归，需要注意的点就是每次递归返回的值不是左右子树最大路径和，而是以左(右)结点为根形成的树的左右子树只能选择其一而构成的最大路径和，因为如果左(右)结点的左子树形成的路径和更大却不能和当前根节点构成一条有效的路径，最大路径和在递归的过程中进行计算，代码如下：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# sel

解题思路：这道题和第84题柱状图中的最大矩形思路是是一样，而且更加简单，这里主需要找到左边第一个更大的元素下标就可以了，84题需要找到左右两边第一个更小的元素下标，因此这道题也可以用两种思路求解：方法一：从右向左，利用右边已知的信息进行路径压缩class Solution: def dailyTemperatures(self, T: List[int]) -> List[int]: size = len(T) res = [0] * size

解题思路：求出以数组中每根柱子为最矮柱子所能延伸的最大的矩形的面积，这些面积的最大值就是所能构成的矩形的最大面积实现方法一：求得i左边的第一根比heights[i]小的柱子的下标记为left_i，求得i右边第一根比heights[i]小的柱子的小标记为right_i，则以柱子heights[i]作为最矮柱子能构成的最大矩形面积为(right_i-left_i-1)*heights[i],代码如下：class Solution: def largestRectangleArea(self, hei

解题思路：构造元{元素：出现次数}的哈希表，然后根据出现次数排序，取出现次数前K多对应的元素class Solution: def topKFrequent(self, nums: List[int], k: int) -> List[int]: tabel = {} for x in nums: tabel[x] = tabel.get(x,0) + 1 res = [] for key, v in t

解题思路：动态规划，坐标（i，j)的路径等于（i-1,j)和（i，j-1)路径之和class Solution: def uniquePaths(self, m: int, n: int) -> int: path = [[1]*m for i in range(n)] for i in range(1,n): for j in range(1,m): path[i][j] = path[i-1][j]

解题思路：滑动窗口，首先找到可行窗口，然后向右滑动左边界，直到当前窗口不包含T中所有字符，然后向右滑动右边界，继续寻找可行窗口，记录整个过程中可行窗口宽度的最小值，以及左右边界class Solution: def minWindow(self, s: str, t: str) -> str: if s == "" or t == "": return "" from collections import Counter

方法一：class Solution: def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: len1 = len(nums1) len2 = len(nums2) length = len1 + len2 i, j = 0, 0 res = [] while((i+j) <= ((len

解题思路一：动态规划，dp[i]表示以s[i]结尾的子串能够构成的有效括号的最大长度，只有当s[i]为‘)‘时才有可能构成有效括号，然后找到离s[i]最近的没有配对的字符，如果这个字符为’('则可以和s[i]配对，代码如下：class Solution: def longestValidParentheses(self, s: str) -> int: size = len(s) if size == 0: return 0