C++博客-Uriel's Corner-文章分类-游标.移动窗口

[LeetCode]977. Squares of a Sorted Array (Easy) Python-2024.03.02

Uriel — Sat, 02 Mar 2024 10:17:00 GMT

给出一个已经从小到大排序的有正有负的数组，输出每个元素的平方并且也要从小到大排序。设两个指针从左和右端向中间扫，之后在逆序输出。

1 #977
2
3 class Solution(object):
4     def sortedSquares(self, nums):
5         """
6         :type nums: List[int]
7         :rtype: List[int]
8         """
9         l = 0
10         r = len(nums) - 1
11         ans = []
12         while l <= r:
13             if nums[l] * nums[l] > nums[r] * nums[r]:
14                 ans.append(nums[l] * nums[l])
15                 l += 1
16             else:
17                 ans.append(nums[r] * nums[r])
18                 r -= 1
19         return ans[::-1]

Uriel 2024-03-02 18:17 发表评论

[LeetCode]1561. Maximum Number of Coins You Can Get (Medium) Python-2023.11.24

Uriel — Fri, 24 Nov 2023 14:41:00 GMT

给出一堆coins，每次取三个，自己拿中间一个，问自己最多能拿多少，贪心，每次取最大的三个的中间一个

1 #1561
2 #Runtime: 516 ms (Beats 18.92%)
3 #Memory: 23.6 MB (Beats 7.21%)
4
5 class Solution(object):
6     def maxCoins(self, piles):
7         """
8         :type piles: List[int]
9         :rtype: int
10         """
11         piles.sort()
12         q = deque(piles)
13         ans = 0
14         while q:
15             q.popleft()
16             q.pop()
17             ans += q[-1]
18             q.pop()
19         return ans

Uriel 2023-11-24 22:41 发表评论

[LeetCode]1658. Minimum Operations to Reduce X to Zero (Medium) Python-2023.09.20

Uriel — Wed, 20 Sep 2023 08:58:00 GMT

给出一列数，每次去掉开头或者结尾的几个数，问最少去掉几次，去掉的数之和等于给定值x，两个游标，右侧游标从左向右，左侧游标也不断向右扫，同时保存当前情况下去掉的最少的数的个数

1 #1658
2 #Runtime: 875 ms (Beats 72.22%)
3 #Memory: 24.3 MB (Beats 74.7%)
4
5 class Solution(object):
6     def minOperations(self, nums, x):
7         """
8         :type nums: List[int]
9         :type x: int
10         :rtype: int
11         """
12         tar_sum = sum(nums) - x
13         l = 0
14         t_sum = 0
15         ans = -1
16         for r in range(len(nums)):
17             t_sum += nums[r]
18             while l <= r and t_sum > tar_sum:
19                 t_sum -= nums[l]
20                 l += 1
21             if tar_sum == t_sum:
22                 ans = max(ans, r - l + 1)
23         return len(nums) - ans if ans != -1 else -1
24

Uriel 2023-09-20 16:58 发表评论

[LeetCode]239. Sliding Window Maximum (Hard) Python-2023.08.16

Uriel — Wed, 16 Aug 2023 08:53:00 GMT

给出一列数nums，求这列数从左到右长度k的滑动窗口内的最大值依次是多少，维护一个优先队列，当计算到第i个数时，优先队列里面保存所有长度k以内值大于nums[i]的数的下标（因此可以保证nums[0]是窗口长度k以内的最大值）

1 #239
2 #Runtime: 1773 ms (Beats 16%)
3 #Memory: 30.5 MB (Beats 48.38%)
4
5 class Solution(object):
6     def maxSlidingWindow(self, nums, k):
7         """
8         :type nums: List[int]
9         :type k: int
10         :rtype: List[int]
11         """
12         wd_max = []
13         ans = []
14         for i in range(len(nums)):
15             if wd_max and wd_max[0] == i - k:
16                 wd_max.pop(0)
17             while wd_max and nums[wd_max[-1]] < nums[i]:
18                 wd_max.pop()
19             wd_max.append(i)
20             if i >= k - 1:
21                 ans.append(nums[wd_max[0]])
22         return ans

Uriel 2023-08-16 16:53 发表评论

[LeetCode]2024. Maximize the Confusion of an Exam (Medium) Python-2023.07.07

Uriel — Fri, 07 Jul 2023 07:56:00 GMT

考卷的所有题目的答案用一列T、F组成的字符串表示，可以操作k次，将T改成F或将F改成T，问最多可以制造多少个连续的T或者F
思路参考 -> https://leetcode.com/problems/maximize-the-confusion-of-an-exam/solutions/3729656/video-solution-sliding-window-2-pointers/
维护两个游标i和j，j走在前，当i～j之间T和F之中最少出现的那一个超过k次时，将这一区间的统一改为T或者F

1 #2024
2 #Runtime: 298 ms (Beats 84.38%)
3 #Memory: 13.6 MB (Beats 96.88%)
4
5 class Solution(object):
6     def maxConsecutiveAnswers(self, answerKey, k):
7         """
8         :type answerKey: str
9         :type k: int
10         :rtype: int
11         """
12         cnt_F, cnt_T = 0, 0
13         i, j = 0, 0
14         ans = 0
15         while j < len(answerKey):
16             if answerKey[j] == 'F':
17                 cnt_F += 1
18             else:
19                 cnt_T += 1
20             while min(cnt_T, cnt_F) > k:
21                 if answerKey[i] == 'F':
22                     cnt_F -= 1
23                 else:
24                     cnt_T -= 1
25                 i += 1
26             ans = max(ans, cnt_F + cnt_T)
27             j += 1
28         return ans

Uriel 2023-07-07 15:56 发表评论

[LeetCode]2090. K Radius Subarray Averages (Medium) Python-2023.06.20

Uriel — Tue, 20 Jun 2023 12:42:00 GMT

求一个数列的某个移动窗口的平均值（窗口大小2*k+1，窗口和整除），若窗口长度不够，该位置输出-1，移动窗口基本应用

1 #2090
2 #Runtime: 1555 ms (Beats 43.86%)
3 #Memory: 33.2 MB (Beats 91.23%)
4
5 class Solution(object):
6     def getAverages(self, nums, k):
7         """
8         :type nums: List[int]
9         :type k: int
10         :rtype: List[int]
11         """
12         t = 0
13         if len(nums) < 2 * k + 1:
14             ans = [-1] * len(nums)
15             return ans
16         ans = [-1] * k
17         for i in range(0, len(nums)):
18             t += nums[i]
19             if i >= 2 * k + 1:
20                 t -= nums[i - 2 * k - 1]
21             if i >= 2 * k:
22                 ans.append(t // (2 * k + 1))
23         if len(nums) > 1:
24             ans.extend([-1] * k)
25         return ans

Uriel 2023-06-20 20:42 发表评论

[LeetCode]1498. Number of Subsequences That Satisfy the Given Sum Condition (Medium) Python-2023.05.06

Uriel — Sat, 06 May 2023 09:28:00 GMT

求一列数的所有子串中，最大最小值之和小于等于给定值target的子串有多少
先sort数列，然后两个指针l和r分别从左向右、从右向左扫，如果当前range的最大最小值之和小于等于target，则l+1，可以取l以及l+1～r的每一位都可取可不取，即2^(r-l)种，否则r-1

1 #1498
2 #Runtime: 9186 ms (Beats 16.87%)
3 #Memory: 23.7 MB (Beats 81.93%)
4
5 class Solution(object):
6     def numSubseq(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         nums.sort()
13         l, ans = 0, 0
14         r = len(nums) - 1
15         MOD = 10**9+7
16         while l <= r:
17             if nums[l] + nums[r] > target:
18                 r -= 1
19             else:
20                 ans += pow(2, r - l) % MOD
21                 l += 1
22         return ans % MOD

Uriel 2023-05-06 17:28 发表评论

[LeetCode]1456. Maximum Number of Vowels in a Substring of Given Length (Medium) Python-2023.05.05

Uriel — Fri, 05 May 2023 07:06:00 GMT

求一列字符串中长度为k的子串最多有多少个元音字母，先预处理到第i个字符有多少个元音字母的累加和，再移动窗口扫一遍

1 #1456
2 #Runtime: 135 ms (Beats 83.33%)
3 #Memory: 18.1 MB (Beats 6.94%)
4
5 class Solution(object):
6     def maxVowels(self, s, k):
7         """
8         :type s: str
9         :type k: int
10         :rtype: int
11         """
12         cnt = [0] * (len(s) + 1)
13         t, ans = 0, 0
14         for i, ch in enumerate(s):
15             if ch in 'aeiou':
16                 t += 1
17             cnt[i + 1] = t
18         for i in range(k, len(cnt)):
19             ans = max(ans, cnt[i] - cnt[i - k])
20         return ans

Uriel 2023-05-05 15:06 发表评论

[LeetCode]881. Boats to Save People (Medium) Python-2023.04.03

Uriel — Mon, 03 Apr 2023 08:27:00 GMT

给出每个人的体重people[i]和小船的载客量limit，每次最多搭载两个人，问最少要几艘船可以运送完所有人，保证人的最大体重不超过载客量
贪心，先对people排序，然后两个游标从左到右，若两者相加超过载客量，则这艘船只搭载右指针重的那个人，右指针向中间移动，否则搭载这两个人，左右指针都向中间移动

1 #881
2 #Runtime: 384 ms (Beats 53.98%)
3 #Memory: 18.9 MB (Beats 18.14%)
4
5 class Solution(object):
6     def numRescueBoats(self, people, limit):
7         """
8         :type people: List[int]
9         :type limit: int
10         :rtype: int
11         """
12         people.sort()
13         p1 = 0
14         p2 = len(people) - 1
15         ans = 0
16         while p1 <= p2:
17             if p1 == p2:
18                 ans += 1
19                 break
20             if people[p1] + people[p2] <= limit:
21                 ans += 1
22                 p1 += 1
23                 p2 -= 1
24             else:
25                 ans += 1
26                 p2 -= 1
27         return ans
28

Uriel 2023-04-03 16:27 发表评论

[LeetCode]2444. Count Subarrays With Fixed Bounds (Hard) Python-2023.03.04

Uriel — Sat, 04 Mar 2023 13:22:00 GMT

给出一串数列，求所有符合以下条件的子序列的数量

子序列所有数的最小值minK，最大值maxK

设两个指针指向符合minK～maxK的最后位置，pos指向最后一个不符合minK～maxK范围的位置，复杂度O(n)

1 #2444
2 #Runtime: 681 ms (Beats 56.52%)
3 #Memory: 24.3 MB (Beats 26.9%)
4
5 class Solution(object):
6     def countSubarrays(self, nums, minK, maxK):
7         """
8         :type nums: List[int]
9         :type minK: int
10         :type maxK: int
11         :rtype: int
12         """
13         pos, l, r = -1, -1, -1
14         cnt = 0
15         for i in range(len(nums)):
16             if minK <= nums[i] <= maxK:
17                 if nums[i] == minK:
18                     l = i
19                 if nums[i] == maxK:
20                     r = i
21                 cnt += max(0, min(l, r) - pos)
22             else:
23                 pos = i
24                 l, r = -1, -1
25         return cnt

Uriel 2023-03-04 21:22 发表评论

[LeetCode]904. Fruit Into Baskets (Medium) Python-2023.02.07

Uriel — Tue, 07 Feb 2023 10:32:00 GMT

有一列fruit，每个fruit有一个label，fruit[i]，有两个篮子，每个篮子只能取相同的fruit，问连续最多可以取多少fruit
sliding window+Counter的又一应用

1 #904
2 #Runtime: 932 ms (Beats 33.9%)
3 #Memory: 19.1 MB (Beats 84.36%)
4
5 class Solution(object):
6     def totalFruit(self, fruits):
7         """
8         :type fruits: List[int]
9         :rtype: int
10         """
11         cur_fruit = Counter()
12         ans, l = 0, 0
13         for r in range(len(fruits)):
14             cur_fruit[fruits[r]] += 1
15             if len(cur_fruit) > 2:
16                 cur_fruit[fruits[l]] -= 1
17                 if cur_fruit[fruits[l]] == 0:
18                     cur_fruit.pop(fruits[l])
19                 l += 1
20             ans = max(ans, r - l + 1)
21         return ans

Uriel 2023-02-07 18:32 发表评论

[LeetCode]438. Find All Anagrams in a String (Medium) Python-2023.02.05

Uriel — Sun, 05 Feb 2023 12:49:00 GMT

给出两个字符串p和s，问p的某种排列是否是s的子串，如果存在，输出所有匹配的位置。类似第567题（http://www.cppblog.com/Uriel/articles/229660.html）
先用Counter计算p各个字符的出现次数，然后用sliding window，s出现在sliding window中的字符对应的Counter减1，发现某位置sliding window让Counter中所有计数归零时记录位置

1 #438
2 #Runtime: 371 ms (Beats 12.21%)
3 #Memory: 14.6 MB (Beats 29.63%)
4
5 class Solution(object):
6     def findAnagrams(self, s, p):
7         """
8         :type s: str
9         :type p: str
10         :rtype: List[int]
11         """
12         cnt_p = Counter(p)
13         l = len(p)
14         ans = []
15         for i in range(len(s)):
16             if s[i] in cnt_p:
17                 cnt_p[s[i]] -= 1
18             if i >= l and s[i-l] in cnt_p:
19                 cnt_p[s[i-l]] += 1
20             if all([cnt_p[j] == 0 for j in cnt_p]):
21                 ans.append(i - l + 1)
22         return ans

Uriel 2023-02-05 20:49 发表评论

[LeetCode]567. Permutation in String (Medium) Python-2023.02.04

Uriel — Sat, 04 Feb 2023 09:28:00 GMT

给出两个字符串s1和s2，问s1的某种排列是否是s2的子串，又一python Counter的应用，先用Counter计算s1各个字符的出现次数，然后用sliding window，s2出现在sliding window中的字符对应的Counter减1，然后判断是否存在某个sliding window让Counter中所有计数归零

1 #567
2 #Runtime: 299 ms (Beats 32.65%)
3 #Memory: 14 MB(Beats 23.38%)
4
5 class Solution(object):
6     def checkInclusion(self, s1, s2):
7         """
8         :type s1: str
9         :type s2: str
10         :rtype: bool
11         """
12         cnt_s1 = Counter(s1)
13         l1 = len(s1)
14         for i in range(len(s2)):
15             if s2[i] in cnt_s1:
16                 cnt_s1[s2[i]] -= 1
17             if i >= l1 and s2[i-l1] in cnt_s1:
18                 cnt_s1[s2[i-l1]] += 1
19             if all([cnt_s1[i] == 0 for i in cnt_s1]):
20                 return True
21         return False

Uriel 2023-02-04 17:28 发表评论

[LeetCode]16. 3Sum Closest (Medium) Python-2022.11.17

Uriel — Thu, 17 Nov 2022 11:29:00 GMT

给一堆数字，第15题是要输出加和正好等于目标数值的所有三个数的三元组，本题是要输出最接近目标数值的三个数之和，默认只有一个答案，用了和第15题类似的思路

先sort list，枚举第一个数i=1~n-2，然后设置两个游标，左边从i+1向右，右边从n向左，更新如果三个数之和于目标值差距，如果三数之和小于目标值，第一个游标右移，否则第二个右边左移

Runtime: 1781 ms, faster than 78.79% of Python online submissions for 3Sum Closest.

Memory Usage: 13.5 MB, less than 52.25% of Python online submissions for 3Sum Closest.

1 #16
2
3 class Solution(object):
4     def threeSumClosest(self, nums, target):
5         """
6         :type nums: List[int]
7         :type target: int
8         :rtype: int
9         """
10         nums.sort()
11         min_diff = 60001
12         for i in range(len(nums)):
13             pos1 = i + 1
14             pos2 = len(nums) - 1
15             while pos1 < pos2:
16                 t_sum = nums[pos1] + nums[pos2] + nums[i]
17                 if abs(target - t_sum) < min_diff:
18                     min_diff = min(min_diff, abs(target - t_sum))
19                     ans = t_sum
20                 if abs(target - t_sum) == 0:
21                     return target
22                 if target > t_sum:
23                     pos1 += 1
24                 else:
25                     pos2 -= 1
26         return ans

Uriel 2022-11-17 19:29 发表评论

[LeetCode]167. Two Sum II - Input Array Is Sorted (Medium) Python-2021.01.27/2022.11.12

Uriel — Sat, 12 Nov 2022 10:28:00 GMT

给一列已经排好序的数，问是否存在其中两个数之和等于给定的target，保证有且仅有一个解
试了两种方法，速度差不多

方法一：左右两个指针分别从首尾开始扫，如果相加小于target则左边指针右移，否则右边指针左移

1 #167
2 #Runtime: 237 ms
3 #Memory Usage: 14.3 MB
4
5 class Solution(object):
6     def twoSum(self, numbers, target):
7         """
8         :type numbers: List[int]
9         :type target: int
10         :rtype: List[int]
11         """
12         l = 0
13         r = len(numbers) - 1
14         while l < r:
15             if numbers[l] + numbers[r] == target:
16                 return [l + 1, r + 1]
17             if numbers[l] + numbers[r] > target:
18                 r -= 1
19             else:
20                 l += 1

方法二：左边指针从第一个数开始向右扫，然后二分查找右边是否存在一个数与当前左边指针的数相加为target

1 #167
2 #Runtime: 243 ms
3 #Memory Usage: 14.9 MB
4
5 class Solution(object):
6     def twoSum(self, numbers, target):
7         """
8         :type numbers: List[int]
9         :type target: int
10         :rtype: List[int]
11         """
12         for i in range(0, len(numbers) - 1):
13             l = i + 1
14             r = len(numbers) - 1
15             while l <= r:
16                 mid = int((l + r) / 2)
17                 #print(mid)
18                 if numbers[i] + numbers[mid] == target:
19                     return([i + 1, mid + 1])
20                 if numbers[i] + numbers[mid] < target:
21                     l = mid + 1
22                 else:
23                     r = mid - 1

Uriel 2022-11-12 18:28 发表评论

[LeetCode]26. Remove Duplicates from Sorted Array (Easy) Python / C-2022.11.11

Uriel — Fri, 11 Nov 2022 10:25:00 GMT

给一列升序数字序列，要求去重，输出最后剩余多少个数（对于没有pop操作的语言，将最后留下的数字排列在数组前部）

Python版：使用pop操作

1 #1047
2 #Runtime: 220 ms
3 #Memory Usage: 14.6 MB
4
5 class Solution(object):
6     def removeDuplicates(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         i = 1
12         while i < len(nums):
13             if i > 0 and nums[i - 1] == nums[i]:
14                 nums.pop(i)
15             else:
16                 i += 1
17         return len(nums)

Python版：不使用pop操作，用游标标记需要把当前数字挪到前面的哪一位（如果当前数字和游标位置的数字不一样）

1 #1047
2 #Runtime: 126 ms
3 #Memory Usage: 14.9 MB
4
5 class Solution(object):
6     def removeDuplicates(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         cnt = 1;
12         for i in range(len(nums) - 1):
13             if nums[cnt - 1] != nums[i + 1]:
14                 cnt += 1
15                 nums[cnt - 1] = nums[i + 1]
16         return cnt

C版：不使用pop操作，用游标标记需要把当前数字挪到前面的哪一位（如果当前数字和游标位置的数字不一样）

1 #1047
2 #Runtime: 27 ms
3 #Memory Usage: 7.4 MB
4
5 int removeDuplicates(int* nums, int numsSize){
6     int cnt = 1;
7     for(int i = 0; i < numsSize - 1; i++) {
8         if(nums[cnt - 1] != nums[i + 1]) {
9             cnt++;
10             nums[cnt - 1] = nums[i + 1];
11         }
12     }
13     return cnt;
14 }

Uriel 2022-11-11 18:25 发表评论

[LeetCode]15. 3Sum (Medium) Python-2022.11.03

Uriel — Thu, 03 Nov 2022 09:16:00 GMT

给一列数，求其中三个数和为0有多少种选择（输出所有可能性，需要去重）

思路一（速度一般）：
先sort list，枚举第一个数i=1~n-2，然后设置两个游标，左边从i+1向右，右边从n向左，如果两个游标对应的数之和小于-nums[i]，第一个游标右移，否则第二个右边左移，如果正好等于-nums[i]，看是否与前一个set重复，不重复则加入答案
一开始尝试记录所有答案，最后去重，会TLE，边处理边判重需要注意方式，当答案集合为空或者不是（第一个数与上一个答案一样第二个数却小于等于上一个答案）时，加入答案集合
"

if tp == [] or not (nums[i] == tp[-1][0] and nums[pos1] <= tp[-1][1]):
"
可以用以下case做测试（自己之前的Output不能通过这个case，WA了一次）：
"

Input:

[-4,-2,-2,-2,0,1,2,2,2,3,3,4,4,6,6]

Output:

[[-4,-2,6],[-4,0,4],[-4,1,3],[-4,2,2],[-2,-2,4],[-2,0,2],[-2,-2,4],[-2,0,2]]

Expected:

[[-4,-2,6],[-4,0,4],[-4,1,3],[-4,2,2],[-2,-2,4],[-2,0,2]]
"

Runtime: 6730 ms, faster than 9.07% of Python online submissions for 3Sum.

Memory Usage: 16.7 MB, less than 79.63% of Python online submissions for 3Sum.

1 #15
2 #Runtime: 6730 ms
3 #Memory Usage: 16.7 MB
4
5 class Solution(object):
6     def threeSum(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[List[int]]
10         """
11         nums.sort()
12         d = {}
13         for i in range(len(nums)):
14             d[nums[i]] = i
15         tp = []
16         ans = []
17         for i in range(len(nums)):
18             pos1 = i + 1
19             pos2 = len(nums) - 1
20             while pos1 < pos2:
21                 if nums[pos1] + nums[pos2] == -nums[i]:
22                     if tp == [] or not (nums[i] == tp[-1][0] and nums[pos1] <= tp[-1][1]):
23                         tp.append([nums[i], nums[pos1], nums[pos2]])
24                     pos1 += 1
25                     pos2 -= 1
26                 elif nums[pos1] + nums[pos2] > -nums[i]:
27                     pos2 -= 1
28                 else:
29                     pos1 += 1
30         return tp

思路二（比思路一快一点）：
先sort，再用dict记录这一列数里面每一种值最后出现的下标位置
两重for循环枚举前两个数i，j，看第三个数在不在dict里，如果在的话，要求下标k>j>i，与思路一一样，注意判断是否与现有的数重复，如果全部加入结果集合最后再判重会TLE

Runtime: 3584 ms, faster than 21.33% of Python online submissions for 3Sum.

Memory Usage: 17.2 MB, less than 19.67% of Python online submissions for 3Sum.

1 #15
2 #Runtime: 3584 ms
3 #Memory Usage: 17.2 MB
4
5 class Solution(object):
6     def threeSum(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[List[int]]
10         """
11         nums.sort()
12         d = {}
13         for i in range(len(nums)):
14             d[nums[i]] = i
15         tp = []
16         ans = []
17         for i in range(len(nums)):
18             for j in range(i + 1, len(nums)):
19                 if -(nums[i] + nums[j]) in d:
20                     k = d[-(nums[i] + nums[j])]
21                     if k > j and (tp == [] or not (nums[i] == tp[-1][0] and nums[j] <= tp[-1][1])):
22                         tp.append([nums[i], nums[j], nums[k]])
23         return tp

Uriel 2022-11-03 17:16 发表评论

[LeetCode]3. Longest Substring Without Repeating Characters (Medium) Python-2022.10.22

Uriel — Sat, 22 Oct 2022 11:54:00 GMT

最长无重复字符子串长度
维护两个指针pos_l和pos_r，每次pos_r右移一位，如果该字符在pos_l~pos_r-1之间已经出现过，则更新该字符最后出现的位置，同时pos_l右移一位，否则，更新最长无重复字符子串长度
一开始没想清楚pos_l的更新，WA*4

1 #3
2 #Runtime: 108 ms
3 #Memory Usage: 13.5 MB
4
5 class Solution(object):
6     def lengthOfLongestSubstring(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         dict_s = {}
12         pos_l = 0
13         pos_r = 0
14         ans = 0
15         while pos_r < len(s):
16             if s[pos_r] in dict_s:
17                 if dict_s[s[pos_r]] >= pos_l:
18                     pos_l = dict_s[s[pos_r]] + 1
19                 dict_s[s[pos_r]] = pos_r
20             else:
21                 dict_s[s[pos_r]] = pos_r
22             ans = max(ans, pos_r - pos_l + 1)
23             pos_r += 1
24         return ans

Uriel 2022-10-22 19:54 发表评论

[LeetCode]76. Minimum Window Substring (Hard) -2022.10.22

Uriel — Sat, 22 Oct 2022 11:24:00 GMT

复杂度O(mn)不晓得能不能猫过，直接想了O(m+n)的
先用字典预处理，判断s是否一定包含t，是的话维护两个指针pos_l和pos_r，从开头扫到结尾，若当区间已经包含t，则更新最短结果+pos_l右移，否则pos_r右移，注意当pos_r移动到最右端时并不能立刻停止，因为pos_l或许可以继续右移，得到更短的答案

因为各种脑残没考虑到的case WA了7次才过。。。

1 #76
2 #Runtime: 302 ms
3 #Memory Usage: 14 MB
4
5 class Solution(object):
6     def minWindow(self, s, t):
7         """
8         :type s: str
9         :type t: str
10         :rtype: str
11         """
12         dict_s ={}
13         for i in s:
14             if i not in dict_s:
15                 dict_s[i] = 1
16             else:
17                 dict_s[i] += 1
18         dict_t ={}
19         for i in t:
20             if i not in dict_t:
21                 dict_t[i] = 1
22             else:
23                 dict_t[i] += 1
24             if i not in dict_s:
25                 return ""
26             if dict_s[i] < dict_t[i]:
27                 return ""
28         pos_l = 0
29         pos_r = 0
30         tp_len_t = len(t)
31         ans_l = 0
32         ans_r = len(s)
33         min_len = len(s)
34         while pos_r < len(s) or tp_len_t <= 0:
35
36             if tp_len_t > 0:
37                 if s[pos_r] in dict_t:
38                     dict_t[s[pos_r]] -= 1
39                     if dict_t[s[pos_r]] >= 0:
40                         tp_len_t -= 1
41                 pos_r += 1
42             else:
43                 if min_len > pos_r - pos_l:
44                     ans_l = pos_l
45                     ans_r = pos_r
46                     min_len = ans_r - ans_l
47                 if s[pos_l] in dict_t:
48                     dict_t[s[pos_l]] += 1
49                     if dict_t[s[pos_l]] > 0:
50                         tp_len_t += 1
51                 pos_l += 1
52
53         return s[ans_l : ans_r]

Uriel 2022-10-22 19:24 发表评论

[LeetCode]219. Contains Duplicate II (Easy) Python-2022.10.21

Uriel — Fri, 21 Oct 2022 22:13:00 GMT

判断一列数里面有没有下标距离<=k的两个相同的数，开个字典标记截至目前某个数最后出现的下标，python字典查找复杂度O(1)

1 class Solution(object):
2     def containsNearbyDuplicate(self, nums, k):
3         """
4         :type nums: List[int]
5         :type k: int
6         :rtype: bool
7         """
8         pos = {}
9         for i in range(len(nums)):
10             if nums[i] in pos and i - pos[nums[i]] <= k:
11                 return True
12             pos[nums[i]] = i
13         return False

Uriel 2022-10-22 06:13 发表评论