memory_MM_forever的博客

从键入url到网页显示，期间发生了什么

memory_MM_forever — Mon, 03 Apr 2023 16:55:26 +0800

流程图总结

动态规划——环形数组的连续子数组最大和

memory_MM_forever — Mon, 18 Apr 2022 20:15:35 +0800

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

动态规划——乘积为正数的最长连续子数组

memory_MM_forever — Mon, 18 Apr 2022 20:05:38 +0800

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

动态规划——连续子数组的最大乘积

memory_MM_forever — Mon, 18 Apr 2022 20:02:08 +0800

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

动态规划——连续子数组的最大和

memory_MM_forever — Mon, 18 Apr 2022 19:56:50 +0800

题目题解 n = int(input()) a = input().split() for i in range(len(a)): a[i] = int(a[i]) dp = [float("-inf")]*n dp[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)

动态规划——最小花费跳台阶

memory_MM_forever — Mon, 18 Apr 2022 19:55:21 +0800

题目题解 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

动态规划——跳台阶扩展

memory_MM_forever — Mon, 18 Apr 2022 19:52:47 +0800

题目题解 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))

动态规划——跳台阶

memory_MM_forever — Mon, 18 Apr 2022 19:27:52 +0800

题目题解 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))

动态规划——斐波那契数列

memory_MM_forever — Mon, 18 Apr 2022 19:25:30 +0800

题目题解 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)

排序：leetcode215（中等）——数组中的第K个最大元素

memory_MM_forever — Fri, 17 Dec 2021 17:42:10 +0800

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

二分：leetcode34（中等）——在排序数组中查找元素的第一个和最后一个位置

memory_MM_forever — Fri, 17 Dec 2021 17:40:32 +0800

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

二分：leetcode69（简单）——Sqrt(x)

memory_MM_forever — Fri, 17 Dec 2021 17:33:12 +0800

题目题解思路：二分，二分模板使用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:

双指针：leetcode524（中等）——通过删除字母匹配到字典里最长单词

memory_MM_forever — Tue, 14 Dec 2021 17:23:01 +0800

题目题解思路：双指针，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

双指针：leetcode680（简单）——验证回文字符串 Ⅱ

memory_MM_forever — Tue, 14 Dec 2021 17:18:45 +0800

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

双指针：leetcode633（中等）——平方数之和

memory_MM_forever — Tue, 14 Dec 2021 17:13:33 +0800

题目题解思路：双指针，取平方根的区间，首尾缩小窗口； 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

双指针：leetcode76（困难）——最小覆盖子串

memory_MM_forever — Tue, 14 Dec 2021 17:09:20 +0800

题目题解思路：滑动窗口，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:

双指针：leetcode142（中等）——环形链表2

memory_MM_forever — Tue, 14 Dec 2021 16:56:17 +0800

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

双指针：leetcode88（简单）——合并两个有序数组

memory_MM_forever — Tue, 14 Dec 2021 16:51:40 +0800

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

双指针：leetcode167（简单）——两数之和2-输入有序数组

memory_MM_forever — Tue, 14 Dec 2021 15:08:14 +0800

题目题解思路：首尾指针向内收缩，比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

C#索引器

memory_MM_forever — Tue, 30 Nov 2021 17:02:37 +0800

class Program { static void Main(string[] args) { Sentence s = new Sentence(); Console.WriteLine(s[3]); s[3] = "kangaroo"; Console.WriteLine(s[3]); } } class Sentence ...