在线视频成人,国产精品日韩电影,9久re热视频在线精品

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

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

�l�出一个已�l�从��到大排序的有正有负的数�l�，输出每个元素的��^方�ƈ且也要从��到大排序。设两个指针从左和右端向中间扫，之后在逆序输出�?br />

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

�l�出一堆coins�Q�每�ơ取三个�Q�自己拿中间一个，问自己最多能拿多��，贪心�Q�每�ơ取最大的三个的中间一�?br />

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

�l�出一列数�Q�每�ơ去掉开头或者结��几个敎ͼ�问最��去掉几�ơ，��L��的数之和�{�于�l�定值x�Q�两个游标，右侧游标从左向右�Q�左侧游标也不断向右扫，同时保存当前情况下去掉的最��的数的个数

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

�l�出一列数nums�Q�求�q�列��C��左到右长度k的滑动窗口内的最大��g��ơ是多少�Q�维护一个优先队列，当计��到�W�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�l�成的字�W�串表示�Q�可以操作k�ơ，��T�Ҏ��F或将F�Ҏ��T�Q�问最多可以制造多��个�q�箋的T或者F
思�\参�?-> https://leetcode.com/problems/maximize-the-confusion-of-an-exam/solutions/3729656/video-solution-sliding-window-2-pointers/
�l�护两个游标i和j�Q�j走在前，当i～j之间T和F之中最��出现的那一个超�q�k�ơ时�Q�将�q�一区间的统一改�ؓ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

求一个数列的某个�U�d��H�口的��^均��|��H�口大小2*k+1�Q�窗口和整除�Q�，若窗口长度不够，该位�|�输�?1�Q�移动窗口基本应�?br />

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

求一列数的所有子串中�Q�最大最��g��和小于等于给定值target的子串有多少
先sort数列�Q�然后两个指针l和r分别从左向右、从叛_��左扫�Q�如果当前range的最大最��g��和小于等于target�Q�则l+1�Q�可以取l以及l+1～r的每一位都可取可不取，�?^(r-l)�U�，否则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

求一列字�W�串中长度�ؓk的子串最多有多少个元韛_��母，先预处理到第i个字�W�有多少个元韛_��母的累加和，再移动窗口扫一�?br />

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

�l�出每个人的体重people[i]和小船的载客量limit�Q�每�ơ最多搭载两个�h�Q�问最��要几艘船可以运送完所有�h�Q�保证�h的最大体重不��过载客�?br />贪心�Q�先对people排序�Q�然后两个游标从左到叻I��若两者相加超�q�蝲客量�Q�则�q�艘船只搭蝲��x��针重的那个�h�Q�右指针向中间移动，否则搭蝲�q�两个�h�Q�左��x��针都向中间移�?br />

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

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

子序列所有数的最��值minK�Q�最大值maxK

设两个指针指向符合minK～maxK的最后位�|�，pos指向最后一个不�W�合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�Q�每个fruit有一个label�Q�fruit[i]�Q�有两个��子�Q�每个篮子只能取相同的fruit�Q�问�q�箋最多可以取多少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

�l�出两个字符串p和s�Q�问p的某�U�排列是否是s的子�Ԍ��如果存在�Q�输出所有匹配的位置。类似第567题（http://m.shnenglu.com/Uriel/articles/229660.html�Q?br />先用Counter计算p各个字符的出现次敎ͼ�然后用sliding window�Q�s出现在sliding window中的字符对应的Counter�?�Q�发现某位置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

�l�出两个字符串s1和s2�Q�问s1的某�U�排列是否是s2的子�Ԍ��又一python Counter的应用，先用Counter计算s1各个字符的出现次敎ͼ�然后用sliding window�Q�s2出现在sliding window中的字符对应的Counter�?�Q�然后判断是否存在某个sliding window让Counter中所有计数归�?br />

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

�l�一堆数字，�W?5题是要输出加和正好等于目标数值的所有三个数的三元组�Q�本题是要输出最接近目标数值的三个��C��和，默认只有一个答案，用了和第15题类似的思�\

先sort list�Q�枚丄��一个数i=1~n-2�Q�然后设�|�两个游标，左边从i+1向右�Q�右边从n向左�Q�更新如果三个数之和于目标值差距，如果三数之和��于目标��|��W�一个游标右�U�，否则�W�二个右边左�U?/span>

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

�l�一列已�l�排好序的数�Q�问是否存在其中两个��C��和等于给定的target�Q�保证有且仅有一个解
试了两种�Ҏ��Q�速度差不�?br />

�Ҏ��一�Q�左右两个指针分别从首尾开始扫�Q�如果相加小于target则左�Ҏ��针右�U�，否则双��指针左移

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

�Ҏ��二：左边指针从第一个数开始向��x��Q�然后二分查扑֏��Ҏ��否存在一个数与当前左�Ҏ��针的数相加�ؓ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

�l�一列升序数字序列，要求去重�Q�输出最后剩余多��个敎ͼ�对于没有pop操作的语�a��Q�将最后留下的数字排列在数�l�前部）

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操作�Q�用游标标记需要把当前数字挪到前面的哪一位（如果当前数字和游标位�|�的数字不一��P��

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操作�Q�用游标标记需要把当前数字挪到前面的哪一位（如果当前数字和游标位�|�的数字不一��P��

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

�l�一列数�Q�求其中三个数和�?有多��种选择�Q�输出所有可能性，需要去重）

思�\一�Q�速度一般）�Q?br />先sort list�Q�枚丄��一个数i=1~n-2�Q�然后设�|�两个游标，左边从i+1向右�Q�右边从n向左�Q�如果两个游标对应的��C��和小�?nums[i]�Q�第一个游标右�U�，否则�W�二个右边左�U�，如果正好�{�于-nums[i]�Q�看是否与前一个set重复�Q�不重复则加入答�?br />一开始尝试记录所有答案，最后去重，会TLE�Q�边处理边判重需要注意方式，当答案集合�ؓ�I�或者不是（�W�一个数与上一个答案一��L��二个数却��于�{�于上一个答案）�Ӟ��加入�{�案集合
"

if tp == [] or not (nums[i] == tp[-1][0] and nums[pos1] <= tp[-1][1]):
"
可以用以下case做测试（自己之前的Output不能通过�q�个case�Q�WA了一�ơ）�Q?br />"

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

思�\二（比思�\一快一点）�Q?br />先sort�Q�再用dict记录�q�一列数里面每一�U�值最后出现的下标位置
两重for循环枚�D前两个数i�Q�j�Q�看�W�三个数在不在dict里，如果在的话，要求下标k>j>i�Q�与思�\一一��P��注意判断是否与现有的数重复，如果全部加入�l�果集合最后再判重会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

最长无重复字符子串长度
�l�护两个指针pos_l和pos_r�Q�每�ơpos_r右移一位，如果该字�W�在pos_l~pos_r-1之间已经出现�q�，则更新该字符最后出现的位置�Q�同时pos_l右移一位，否则�Q�更新最长无重复字符子串长度
一开始没��x��楚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)不晓得能不能猫过�Q�直接想了O(m+n)�?br />先用字典预处理，判断s是否一定包含t�Q�是的话�l�护两个指针pos_l和pos_r�Q�从开头扫到结��，若当区间已经包含t�Q�则更新最短结�?pos_l右移�Q�否则pos_r右移�Q�注意当pos_r�U�d��到最右端时�ƈ不能立刻停止�Q�因为pos_l或许可以�l�箋右移�Q�得到更短的�{�案

因�ؓ各种脑残没考虑到的case WA�?�ơ才�q�。。�?br />

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

判断一列数里面有没有下标距��?lt;=k的两个相同的敎ͼ�开个字典标记截至目前某个数最后出现的下标�Q�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 发表评论