memory_MM_forever的博客

题目题解求最大和可以反过来先求最小和，最大和跟最小和的数组必定首尾相连，中间不可能有空位，分成两个数组，如果最小和是从尾部跳到首部，那最大和就在数组中间，就是正常的dpmax，如果最大和是从尾部跳到首部，那最小和就在数组中间，就是正常的dpmin，sum-dpmin就是最大和；特殊情况，如果dpmin=sum就代表全是负数，也是正常的dpmax；n = int(input())a = list(map(int,input().split()))dpmax = [0] * ndpmax[0] =

题目题解pos[i]为到第i个数为止乘积为正数的最长长度；neg[i]为到第i个数为止乘积为负数的最长长度；n = int(input())a = list(map(int,input().split()))pos = [0]*nneg = [0]*nif a[0] > 0: pos[0] = 1elif a[0] < 0: neg[0] = 1res = pos[0]for i in range(1,n): if a[i] > 0:

题目题解如果当前数字为正，那到第i-1个的最大乘积乘以当前数字；如果当前数字为负，那到第i-1个的最小乘积乘以当前数字；n = int(input())a =list(map(int, input().split())) dp1 = [float("-inf")]*ndp2 = [float("-inf")]*ndp1[0] = a[0]dp2[0] = a[0]res = dp1[0]for i in range(1,n): dp1[i] = max(dp1[i-1

题目题解n = int(input())a = input().split()for i in range(len(a)): a[i] = int(a[i])dp = [float("-inf")]*ndp[0] = a[0]res = a[0]for i in range(1,n): dp[i] = max(dp[i-1] + a[i],a[i]) res = max(res,dp[i])print(res)

题目题解n = int(input())cost = input().split()for i in range(n): cost[i] = int(cost[i])def func(n): dp = [0]*(n+1) dp[2] = min(cost[0],cost[1]) for i in range(3, n+1): dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]) retu

题目题解n = int(input())def func(n): if n <= 2: return n dp = [1]*(n+1) for i in range(2, n+1): j = i dp[i] = 0 for i2 in range(0, j): dp[i] += dp[i2] return dp[n]print(func(n))

题目题解n = int(input())def func(n): if n <= 2: return n dp = [1] * (n + 1) for i in range(2, n+1): dp[i] = dp[i-1] + dp[i-2] return dp[n]print(func(n))

题目题解n = int(input())f1, f2,res =1, 1, 1 if n <= 2: print(res)else: for i in range(n-2): res= f1 + f2 f1 = f2 f2 = res print(res)

题目题解class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: n = len(nums) - 1 nums = sorted(nums) return nums[n-k+1]

题目题解思路：二分二分模板1：while l < r: mid = (l + r)//2 if 条件: r = mid else: l = mid + 1return r二分模板2：while l < r: mid = (l + r + 1)//2 if 条件: l = mid else: r = mid - 1return r根据使用策略使用两种模板，例如本

题目题解思路：二分，二分模板使用34题模板，循环最后求出第一个平方数大于等于x的值，因为向下取整，所以最后如果是大于，减1，等于直接返回；class Solution: def mySqrt(self, x: int) -> int: l = 0 r = x while l < r: mid = (l + r) // 2 if mid * mid >= x:

题目题解思路：双指针，s中包含进dictionary中当前元素，就可以开始判断结果：当前的ch更大就可以替换，或者长度相等时判断字母序；class Solution: def findLongestWord(self, s: str, dictionary: List[str]) -> str: res = "" for ch in dictionary: i = j = 0 while i < len

题目题解思路：因为只允许最多删除一个字母，所以要么删左边，要么删右边，并且删完后只需要判断中间的还没判断的区间就可以；class Solution: def validPalindrome(self, s: str) -> bool: def checkPalindrome(low, high): #判断是否是回文字符串 i, j = low, high while i < j: if

题目题解思路：双指针，取平方根的区间，首尾缩小窗口；class Solution: def judgeSquareSum(self, c: int) -> bool: i = 0 j = int(math.sqrt(c)) while i<= j: sum = i*i + j*j if sum > c: j -= 1 if

题目题解思路：滑动窗口，need记录t中每个字母的需要数量，needAll记录t的总字母数，两个指针同时从头起步，移动j，确定包含了t的所有字母，再移动i，计算最小的窗口；得到当前的最小窗口后再移动i，继续求下一个满足条件的窗口；class Solution: def minWindow(self, s: str, t: str) -> str: need = collections.defaultdict(int) for c in t:

题目题解思路：floyd判圈法；# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def detectCycle(self, head: ListNode) -> ListNode: fast, slow

题目题解思路：合并进新数组，剩下的那个数组一起合并进去，再赋值给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. """ nums3 = list()

题目题解思路：首尾指针向内收缩，比target大，就收缩尾指针，比target小，就收缩首指针，等于就返回；class Solution: def twoSum(self, numbers: List[int], target: int) -> List[int]: nums = list() x, y = 0, len(numbers)-1 while x < y: if numbers[x] + numb

题目题解思路：三个数：i-2, i-1, i; 如果nums[i-1]>nums[i]，并且nums[i-2]<=nums[i]，那么最佳的方式是将nums[i-1]的值设为nums[i]的值，因为nums[i-1]的值越大，对前面的元素影响就越小；修改nums[i]可能会影响到后面的还未遍历的元素；但是如果nums[i-2]>nums[i], 就不可能让nums[i-1]在大于等于nums[i-2]的同时又小于等于nums[i]，此时只能修改nums[i]的值为nums[i-1]

题目题解思路：用纸笔多尝试几次不难发现排序的规律，我的尝试方法是：首先身高最高的必定存在k=0，以这个为基准可以发现排序的规律；例如示例数组：[[7, 0], [4, 4], [7, 1], [5, 0], [6, 1], [5, 2]]；先选[7,0],接着[7,1]放[7,0]后面，然后[6,1]、[5,0]、[5,2]…这么排的原因是，先排高的人，再插入矮个子就不会对现有元素的k造成影响；class Solution: def reconstructQueue(self, peop

题目题解思路：1.首先每个人至少一块糖果2.循环两遍数组，从左往右，右边分高的至少比左边多一块；从右往左，因为这个时候可能左边分比右边高的同时糖果比右边多，这个时候维持原状，糖果比右边少的话就要比右边多一个class Solution: def candy(self, ratings: List[int]) -> int: n = len(ratings) nums = [1]*n #每人最少有一块 for i in rang

题目题解思路：一个区间越小，就能留出更多的空间分给其他区间。如果后面一个区间的头小于前面一个区间的尾，就移除后面的区间；如果不需要移除，就把它们两合并成新的区间；class Solution: def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int: intervals.sort(key=lambda x: x[1]) removed=0; right=inte

题目题解思路：官方的题解主要是数学规律的查找，prev为上一朵种植的花的位置：1.如果位置 i 为1且前面都为0，可以种 i//2 朵花；如前面有 1 ， 可以种 (i-prev-2)//2 朵花；如果遍历的过程中count>=n,就直接结束，不需要再计算2.最后一个区间为最后的1的右侧区间，可以种（m-prev-1）//2 朵花；3.特殊情况：整个数组都是0，可以种（m+1）//2 朵花；class Solution: def canPlaceFlowers(self, fl

题目题解思路：一把箭要穿过最多的区间，那它一定在某个区间的最右侧，如果下个区间不在这个区间的范围，就换新箭，并且位置更新为下个区间的尾部class Solution: def findMinArrowShots(self, points: List[List[int]]) -> int: points.sort(key=lambda x: x[1]) pos = points[0][1] ans = 1 for ballo

题目题解思路：单开一个数组记录每个字母最后出现的位置，对于遍历到的字母，记录它出现的最后位置为end，每次遍历都更新end，如果已经遍历到end的位置，就说明从start到end为止的字母为一个区间，其中的字母都不可能会在后面再出现，把它加入数组；class Solution: def partitionLabels(self, s: str) -> List[int]: last = [0]*26 for i,ch in enumerate(s):

题目题解思路：官方贪心题解虽然求不出怎么交易的，但是可以求出最大的利润，方法是只要是正向区间就加入到利润里，这样就是一直在盈利；class Solution: def maxProfit(self, prices: List[int]) -> int: n = len(prices) money = 0 for i in range(1, n): money += max(0, prices[i]-prices[

题目题解思路：每个孩子给满足条件的最小的饼干class Solution: def findContentChildren(self, g: List[int], s: List[int]) -> int: g.sort() s.sort() i = j = count = 0 while i < len(g) and j < len(s): if g[i] <= s[j]: