久久这里只精品99re66,久久久国产精华液,国产激情久久久久影院小草

[LeetCode]455. Assign Cookies (Easy) Python-2024.01.01

Uriel — Mon, 01 Jan 2024 13:13:00 GMT

数组g表示每个��盆友需要什么size的饼�qԌ��数组s表示每个饼干的size�Q�问�q�堆饼干s最多能满��多少位小盆友的要求，贪心�Q�分别对g和s从小到大排序�Q�然后设两个游标挨个比较

1 #455
2 #Runtime: 230 ms (Beats 12.76%)
3 #Memory: 15 MB (Beats 6.38%)
4
5 class Solution(object):
6     def findContentChildren(self, g, s):
7         """
8         :type g: List[int]
9         :type s: List[int]
10         :rtype: int
11         """
12         g.sort()
13         s.sort()
14         p1, p2 = 0, 0
15         while p1 < len(g) and p2 < len(s):
16             if g[p1] <= s[p2]:
17                 p1 += 1
18                 p2 += 1
19             else:
20                 p2 += 1
21         return p1

Uriel 2024-01-01 21:13 发表评论

[LeetCode]1578. Minimum Time to Make Rope Colorful (Medium) Python-2023.12.27

Uriel — Wed, 27 Dec 2023 09:38:00 GMT

a-z代表不同颜色的气球，盔R��气球颜色相同的话每次可以保留其中一个，��p��旉��Z��者needTime中间的较��|��问消除全部的盔R��气球的最��总花费，贪心

#1578
#Runtime: 812 ms (Beats 62.22%)
#Memory: 22.1 MB (Beats 88.89%)

class Solution(object):
    def minCost(self, colors, neededTime):
        """
        :type colors: str
        :type neededTime: List[int]
        :rtype: int
        """
        ans = 0
        for i in xrange(1, len(neededTime)):
            if colors[i] == colors[i - 1]:
                ans += min(neededTime[i], neededTime[i - 1])
                neededTime[i] = max(neededTime[i - 1], neededTime[i])
        return ans

Uriel 2023-12-27 17:38 发表评论

[LeetCode]1903. Largest Odd Number in String (Easy) Python-2023.12.07

Uriel — Fri, 08 Dec 2023 16:16:00 GMT

输出一个字�W�串的最大奇数子�Ԍ��贪心�Q�从最后一位向前找奇数

1 #1903
2 #Runtime: 27 ms (Beats 98.59%)
3 #Memory: 15.3 MB (Beats 81.69%)
4
5 class Solution(object):
6     def largestOddNumber(self, num):
7         """
8         :type num: str
9         :rtype: str
10         """
11         p = -1
12         for i in xrange(len(num) - 1, -1, -1):
13             if (ord(num[i]) - ord('0')) % 2:
14                 p = i
15                 break
16         return num[0:p+1]
17

Uriel 2023-12-09 00:16 发表评论

[LeetCode]1727. Largest Submatrix With Rearrangements (Medium) Python3-2023.12.01

Uriel — Fri, 01 Dec 2023 13:36:00 GMT

rearrange二维矩阵的列�Q�问能构成的最大的�?子矩阉|��多大�Q�贪心，先按列求每一行的prefix sum�Q�因��序不能换，所以遇�?的话要清0�Q�，然后遍历每一行，更新最大子矩阵��寸

1 #1727
2 #Runtime: 1041 ms (Beats 11.18%)
3 #Memory: 44.8 MB (Beats 45.71%)
4
5 class Solution(object):
6     def largestSubmatrix(self, matrix):
7         """
8         :type matrix: List[List[int]]
9         :rtype: int
10         """
11         r, c = len(matrix), len(matrix[0])
12         ans = 0
13         for i in xrange(1, r):
14             for j in xrange(c):
15                 matrix[i][j] += matrix[i - 1][j] if matrix[i][j] else 0
16         for i in xrange(r):
17             matrix[i].sort(reverse=True)
18             for j in xrange(c):
19                 ans = max(ans, (j + 1) * matrix[i][j])
20         return ans

Uriel 2023-12-01 21:36 发表评论

[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]1877. Minimize Maximum Pair Sum in Array (Medium) Python-2023.11.17

Uriel — Fri, 17 Nov 2023 13:10:00 GMT

�l�出一列数�Q�将其中的数分成若干pair要求pair之和的最大值最��，sort然后贪心每次从最��和最大的一端取一个数

1 #1877
2 #Runtime: 939 ms (Beats 68.83%)
3 #Memory: 25.7 MB (Beats 14.29%)
4
5 class Solution(object):
6     def minPairSum(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         nums.sort()
12         ans = 0
13         n = len(nums)
14         for i in xrange(n//2):
15             ans = max(ans, nums[i] + nums[n - i - 1])
16         return ans

Uriel 2023-11-17 21:10 发表评论

[LeetCode]1846. Maximum Element After Decreasing and Rearranging (Medium) Python-2023.11.15

Uriel — Wed, 15 Nov 2023 14:01:00 GMT

对一列数�q�行reorder和decrease�Q��得这列数�?开始，盔R��数差别不��过1�Q�问数列里最大值是多少�Q�贪�?br />

1 #1846
2 #Runtime: 359 ms (Beats 100%)
3 #Memory: 21.7 MB (Beats 5.56%)
4
5 class Solution(object):
6     def maximumElementAfterDecrementingAndRearranging(self, arr):
7         """
8         :type arr: List[int]
9         :rtype: int
10         """
11         arr.sort()
12         st = 1
13         for x in arr[1:]:
14             if x > st:
15                 st += 1
16         return st

Uriel 2023-11-15 22:01 发表评论

[LeetCode]1921. Eliminate Maximum Number of Monsters (Medium) Python-2023.11.07

Uriel — Tue, 07 Nov 2023 09:23:00 GMT

�l�出每个monster的距��M��及行�q�速度�Q�每�ơ装备需�?个单位时��_��问最多可以灭掉几个monster�Q�如果monster到达的时候未装备�Q�则宣告��p�|。先预处理每个monster到达的时��_��注意用��Q�Ҏ��Q�，然后sort�Q�看有多��monster可以在i旉��内到�?br />

#1921
#Runtime: 690 ms (Beats 57.14%)
#Memory: 35.4 MB (Beats 19.5%)

class Solution(object):
    def eliminateMaximum(self, dist, speed):
        """
        :type dist: List[int]
        :type speed: List[int]
        :rtype: int
        """
        mon = []
        for d, s in zip(dist, speed):
            mon.append(1.0 * d / s)
        mon.sort()
        ans = 0
        for i in xrange(len(mon)):
            if mon[i] > i:
                ans += 1
            else:
                break
        return ans

Uriel 2023-11-07 17:23 发表评论

[LeetCode]2038. Remove Colored Pieces if Both Neighbors are the Same Color (Medium) Python-2023.10.02

Uriel — Mon, 02 Oct 2023 09:49:00 GMT

�l�出一列A和B�l�成的字�W�串�Q�选手A和B轮流操作�Q�每�ơA看到三个相连的A�Q�则可以��L��中间的A�Q�B看到三个相连的B�Q�则可以��L��中间的B�Q�如果谁先无法找到可消除的字母，则输�Q�输出A是否能赢
每次把三个相�ȝ��C��间一个去掉，�q�不会媄响对手可选择的消除位�|�，于是直接�l�计三个A和B�Q�若有四个相邻，�l�计两次�Q?br />

1 #2038
2 #Runtime: 166 ms (Beats 83.6%)
3 #Memory: 14.8 MB (Beats 89.52%)
4
5 class Solution(object):
6     def winnerOfGame(self, colors):
7         """
8         :type colors: str
9         :rtype: bool
10         """
11         a = 0
12         for i in xrange(1, len(colors) - 1):
13             if colors[i - 1] == colors[i] == colors[i + 1]:
14                 if colors[i] == 'A':
15                     a += 1
16                 else:
17                     a -= 1
18         return a > 0

Uriel 2023-10-02 17:49 发表评论

[LeetCode]1647. Minimum Deletions to Make Character Frequencies Unique (Medium) Python-2023.09.12

Uriel — Tue, 12 Sep 2023 09:17:00 GMT

�l�出一堆字�W�，问最��去掉几个字�W�可以保证每�U�字�W�出现的�ơ数不同�Q�用python的counter�l�计�ơ数�Q�然后用set记录已经出现�q�的字符频次�Q�若有冲�H�，不断��L��字符直至不冲�H?br />

1 #1647
2 #Runtime: 274 ms (Beats 29.54%)
3 #Memory: 14.2 MB (Beats 87.50%)
4
5 class Solution(object):
6     def minDeletions(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         ans = 0
12         fq_set = set()
13         cnt = collections.Counter(s)
14         for ch, fq in cnt.items():
15             while fq  and fq in fq_set:
16                 fq -= 1
17                 ans += 1
18             fq_set.add(fq)
19         return ans

Uriel 2023-09-12 17:17 发表评论

[LeetCode]2366. Minimum Replacements to Sort the Array (Hard) Python-2023.08.30

Uriel — Wed, 30 Aug 2023 20:53:00 GMT

�l�出一个数列，每一�ơ操作可以将其中一个数换成两个敎ͼ�两数之和和原��C��P��问最��几�ơ操作可以将数列变成单调不减�Q�贪心思想�Q�最后一个数作�ؓ初始��|��如果前一个数比他大，��量分裂成更大更相等的几个数�Q�不断和前一个数比直到数列头

1 #2366
2 #Runtime: 432 ms (Beats 100%) Sorry, there are not enough accepted submissions to show data
3 #Memory: 25.8 MB (Beats 100%) Sorry, there are not enough accepted submissions to show data
4
5 class Solution(object):
6     def minimumReplacement(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         pre = nums[-1]
12         ans = 0
13         for i in range(len(nums) - 1, -1, -1):
14             d = nums[i] // pre
15             if nums[i] % pre != 0:
16                 d += 1
17             ans += d - 1
18             pre = nums[i] // d
19         return ans

Uriel 2023-08-31 04:53 发表评论

[LeetCode]767. Reorganize String (Medium) Python-2023.08.23

Uriel — Wed, 23 Aug 2023 08:31:00 GMT

��一列字�W�串中的字符重新排序�Q��得相��d��W�不相同
贪心思想�Q�用priority queue��字�W�按照出现次��C��多到��排序，然后一�ơ填入结果字�W�串�Q�如果单�U�字�W�次数超�q�字�W�串总长度一半，则不能实现。先填充所有奇��C��Q�然后填偶数�?br />

1 #767
2 #Runtime: 11 ms (Beats 98.89%)
3 #Memory: 13.5 MB (Beats 11.11%)
4
5 class Solution(object):
6     def reorganizeString(self, s):
7         """
8         :type s: str
9         :rtype: str
10         """
11         n = len(s)
12         freq = defaultdict(int)
13         for i in range(n):
14             freq[s[i]] += 1
15         hp = [(-v, k) for k, v in freq.items()]
16         heapify(hp)
17         i = 0
18         ans = [""] * n
19         while hp:
20             v, k = heappop(hp)
21             if 2 * (-v) - 1 > n:
22                 return ""
23             for _ in range(-v):
24                 ans[i] = k
25                 if i + 2 < n:
26                     i += 2
27                 else:
28                     i = 1
29         return "".join(ans)

Uriel 2023-08-23 16:31 发表评论

[LeetCode]2616. Minimize the Maximum Difference of Pairs (Medium) Python-2023.08.09

Uriel — Wed, 09 Aug 2023 13:53:00 GMT

�l�出一列数�Q�找出p�Ҏ��字（每个数只能最多用一�ơ）�Q�问�q�p�Ҏ��字两两之差之和最��多��，直接二分�l�果�Q�若想两两之差小�Q�那么就是sort之后每次选相�ȝ��?br />

1 #2616
2 #Runtime: 831 ms (Beats 100%)
3 #Memory: 25.4 MB (Beats 100%)
4
5 class Solution(object):
6     def minimizeMax(self, nums, p):
7         """
8         :type nums: List[int]
9         :type p: int
10         :rtype: int
11         """
12         n = len(nums)
13         nums.sort()
14         l, r = 0, nums[-1] - nums[0]
15
16         def cal(dif):
17             nt = 0
18             i = 1
19             while i < len(nums):
20                 if nums[i] - nums[i - 1] <= dif:
21                     i += 1
22                     nt += 1
23                 i += 1
24             return nt
25
26         while l < r:
27             mid = (l + r) // 2
28             if cal(mid) >= p:
29                 r = mid
30             else:
31                 l = mid + 1
32         return l

Uriel 2023-08-09 21:53 发表评论

[LeetCode]435. Non-overlapping Intervals (Medium) Python-2023.07.19

Uriel — Wed, 19 Jul 2023 09:22:00 GMT

�l�出一些intervals的开始和�l�束点，问最��去掉几个interval可以保证剩下的intervals没有overlap�Q�贪心思�\�Q�先�l�intervals排序�Q�先按开始节�Ҏ��Q�相同的话按�l�束节点排）�Q�之后依�ơ处理，如果当前的interval开始节点大于前一个结束节点，那这一interval不能��L��Q�否则去掉当前interval�q�且更新�l�束节点

1 #435
2 #Runtime: 1421 ms (Beats 25.19%)
3 #Memory: 59.8 MB (Beats 44.83%)
4
5 class Solution(object):
6     def eraseOverlapIntervals(self, intervals):
7         """
8         :type intervals: List[List[int]]
9         :rtype: int
10         """
11         intervals.sort()
12         ans = 0
13         pre = intervals[0][1]
14         for st, ed in intervals[1:]:
15             if st >= pre:
16                 pre = ed
17             else:
18                 ans += 1
19                 pre = min(ed, pre)
20         return ans

Uriel 2023-07-19 17:22 发表评论

[LeetCode]2551. Put Marbles in Bags (Hard) Python-2023.07.08

Uriel — Sat, 08 Jul 2023 20:02:00 GMT

�l�出一堆石子的重量�Q�分到k个包里，每个包需要i～j�q�箋堆全部取完，每堆的cost为weights[i]+weights[j]�Q�求不同的分配方式里面k堆的总cost最大值和最��g��?br />思�\参�?-> https://leetcode.com/problems/put-marbles-in-bags/solutions/3734284/sort-video-solution/

1 #2551
2 #Runtime: 758 ms (Beats 16.67%)
3 #Memory: 25.1 MB (Beats 16.67%)
4
5 class Solution(object):
6     def putMarbles(self, weights, k):
7         """
8         :type weights: List[int]
9         :type k: int
10         :rtype: int
11         """
12         n = len(weights)
13         p = [0] * (n - 1)
14         for i in range(1, n):
15             p[i - 1] = weights[i] + weights[i - 1]
16         p.sort()
17         minx, maxx = 0, 0
18         for i in range(k - 1):
19             minx += p[i]
20             maxx += p[n - i - 2]
21         return maxx - minx

Uriel 2023-07-09 04:02 发表评论

[LeetCode]2439. Minimize Maximum of Array (Medium) Python-2023.04.05

Uriel — Wed, 05 Apr 2023 09:28:00 GMT

�l�出一个数列每�ơ可以将下标i的数-1�Q�将下标i-1的数+1�Q�执行此操作无限多次�Q��得最后得到的数列的最大值最��，求这个�?br />�q�个操作不改变数列的�q�_��|��让最大值最��就是让数列��可能��^均，于是求数列所有的前缀的��^均值里面最大的卛_��

1 #2439
2 #Runtime: 637 ms (Beats 60%)
3 #Memory: 23.3 MB (Beats 80%)
4
5 class Solution(object):
6     def minimizeArrayValue(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         ans, cnt = 0, 0
12         for i in range(len(nums)):
13             cnt += nums[i]
14             ans = max(ans, ceil(1.0 * cnt / (i + 1)))
15         return int(ans)

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

[LeetCode]1402. Reducing Dishes (Hard) Python-2023.03.29

Uriel — Wed, 29 Mar 2023 10:04:00 GMT

�l�出一些菜品的满意��|��可以选择做其中的0~所有菜�Q�最后�ȝ��满意度计��方式�ؓsum(time[i] * satisfaction[i])�Q�time[i]=i是指该道菜是�W�i个做的，贪心�Q�越满意的菜品越后做�Q�这样time[i]更大
实际做的时候将菜品按满意度从大到小排序�Q�不断篏加满意度��|��如果到某一时刻累加��gؓ负，后面的菜都不用考虑�?br />

1 #1402
2 #Runtime: 16 ms (Beats 100%)
3 #Memory: 13.5 MB (Beats 70.27%)
4
5 class Solution(object):
6     def maxSatisfaction(self, satisfaction):
7         """
8         :type satisfaction: List[int]
9         :rtype: int
10         """
11         satisfaction.sort(reverse=True)
12         ans, tp = 0, 0
13         for i in range(len(satisfaction)):
14             tp += satisfaction[i]
15             if tp < 0:
16                 break
17             ans += tp
18         return ans

Uriel 2023-03-29 18:04 发表评论

[LeetCode]605. Can Place Flowers (Easy) Python-2023.03.20

Uriel — Mon, 20 Mar 2023 07:38:00 GMT

�l�出一�?�Q?�l�成的list�Q�要�?不能盔R��攄��Q�问是否可以再向其中插入n�?�Q�简单贪心，从左�Ҏ��?开始，�W�合要求��放1�Q�看最后能不能攄��>=n�?br />

1 #605
2 #Runtime: 119 ms (Beats 83.80%)
3 #Memory: 14.3 MB (Beats 19.44%)
4
5 class Solution(object):
6     def canPlaceFlowers(self, flowerbed, n):
7         """
8         :type flowerbed: List[int]
9         :type n: int
10         :rtype: bool
11         """
12         x = 0
13         for i in range(len(flowerbed)):
14             if flowerbed[i] == 0:
15                 if i >= 1:
16                     if flowerbed[i - 1] == 1:
17                         continue
18                 if i < len(flowerbed) - 1:
19                     if flowerbed[i + 1] == 1:
20                         continue
21                 flowerbed[i] = 1
22                 x += 1
23         return x >= n

Uriel 2023-03-20 15:38 发表评论

[LeetCode]1675. Minimize Deviation in Array (Hard) Python-2023.02.25

Uriel — Sat, 25 Feb 2023 12:31:00 GMT

�l�出一列数�Q�对于奇敎ͼ�可以*2�Q�对于偶敎ͼ�可以/2�Q�问执行��L��多次操作之后�Q�这列数的最大最��g��差最��是多少

参考了�Q�https://leetcode.com/problems/minimize-deviation-in-array/solutions/3223578/priority-queue-video-java-c-python/

利用python的heapq

1 #1675
2 #Runtime: 5340 ms (Beats 100%)
3 #Memory: 19.7 MB (Beats 100%)
4 (Sorry, there are not enough accepted submissions to show data)
5
6 class Solution(object):
7     def minimumDeviation(self, nums):
8         """
9         :type nums: List[int]
10         :rtype: int
11         """
12         q = []
13         q_min = 2000000000
14         for i in nums:
15             if i % 2:
16                 i *= 2
17             heapq.heappush(q, -i)
18             q_min = min(q_min, i)
19
20         ans = -q[0] - q_min
21         while q[0] % 2 == 0:
22             t = -heapq.heappop(q)
23             heapq.heappush(q, -(t // 2))
24             ans = min(ans, t - q_min)
25             q_min = min(q_min, t // 2)
26         return min(ans, -q[0] - q_min)

Uriel 2023-02-25 20:31 发表评论

[LeetCode]502. IPO (Hard) Python-2023.02.23

Uriel — Thu, 23 Feb 2023 16:07:00 GMT

有n个projects�Q�每个需要capacity[i]才能启动�Q�获利profits[i]�Q�初始拥有w capacity�Q�问完成最多k个projects可以最多获利多��?br />利用heap�Q�or优先队列�Q�的贪心
先按照capacity从小到大对projects排序�Q�然后从�W�一个project开始，如果capacity��于当前的w�Q�则加入heap�Q�直到capacity的要求大于当前w�Q�然后去完成heap��端的project

1 #502
2 #Runtime: 1335 ms (Beats 51.90%)
3 #Memory: 37.9 MB (Beats 69.62%)
4
5 class Solution(object):
6     def findMaximizedCapital(self, k, w, profits, capital):
7         """
8         :type k: int
9         :type w: int
10         :type profits: List[int]
11         :type capital: List[int]
12         :rtype: int
13         """
14         n = len(profits)
15         proj = list(zip(capital, profits))
16         proj.sort()
17         j = 0
18         q = []
19         for i in range(k):
20             while j < n and proj[j][0] <= w:
21                 heappush(q, -proj[j][1])
22                 j += 1
23             if not q:
24                 break
25             w += -heappop(q)
26         return w

Uriel 2023-02-24 00:07 发表评论

[LeetCode]926. Flip String to Monotone Increasing (Medium) Python-2023.01.17

Uriel — Tue, 17 Jan 2023 12:52:00 GMT

�l�一串由0�?�l�成的字�W�串�Q�每�ơ操作把其中一位从0�?或者从1�?�Q�问臛_��几次操作可以让整个字�W�串变成从左臛_��单调�?br />参考了Discussion的��y妙思�\->https://leetcode.com/problems/flip-string-to-monotone-increasing/solutions/3061225/python-3-7-lines-w-explanation-and-example-t-m-100-96/

1 #926
2 #Runtime: 92 ms (Beats 95.45%)
3 #Memory: 14.6 MB (Beats 95.45%)
4
5 class Solution(object):
6     def minFlipsMonoIncr(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         t, ans = 0, 0
12         for i in s:
13             if i == '1':
14                 t += 1
15             elif t:
16                 ans += 1
17                 t -= 1
18         return ans
19

Uriel 2023-01-17 20:52 发表评论

[LeetCode]134. Gas Station (Medium) C++/Python-2014.01.09/2023.01.07

Uriel — Sat, 07 Jan 2023 10:01:00 GMT

一些加油站构成一个环路，�l�出每个加��a站i可以加的沚w��gas[i],以及从idaoi+1需要的沚w��cost[i]�Q�问是否可以从某个加油站开始顺旉��遍历所有加油站

从第一个加油站开始，假设从该站出发，然后依次遍历�Q�如果发现到达某个加油站时库存��a量加上该站加入的沚w��无法到达下一站，则重�|�，从下一站出发，在遍历时累加所有站的gas[i]-cost[i]�Q�如果��d��于0�Q�则输出-1

C++�?br />

1 //134
2 //Runtime: 52 ms (Beats 100%)
3
4 class Solution {
5 public:
6     int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
7         int sum = 0, cnt = 0, st = 0;
8         for(int i = 0; i < gas.size(); ++i) {
9             sum += gas[i] - cost[i];
10             cnt += gas[i] - cost[i];
11             if(sum < 0) {
12                 sum = 0;
13                 st = (i + 1) % gas.size();
14             }
15         }
16         if(cnt < 0) return -1;
17         return st;
18     }
19 };

Python�?br />

1 #134
2 #Runtime: 551 ms (Beats 85.35%)
3 #Memory: 20.2 MB (Beats 26.28%)
4
5 class Solution(object):
6     def canCompleteCircuit(self, gas, cost):
7         """
8         :type gas: List[int]
9         :type cost: List[int]
10         :rtype: int
11         """
12         cur_gas = 0
13         tol_gas = 0
14         ans = 0
15         for i in range(len(gas)):
16             tol_gas += gas[i] - cost[i]
17             cur_gas = cur_gas + gas[i] - cost[i]
18             if cur_gas < 0:
19                 cur_gas = 0
20                 ans = (i + 1) % len(gas)
21         if tol_gas < 0:
22             return -1
23         return ans

Uriel 2023-01-07 18:01 发表评论

[LeetCode]1833. Maximum Ice Cream Bars (Medium) Python-2023.01.06

Uriel — Fri, 06 Jan 2023 12:31:00 GMT

@import url(http://www.shnenglu.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); �l�出每个ice cream的�h格costs[i]�Q�一共有coins钱，问最多买多少ice cream�Q�贪心水题，直接按costs排序从�h格由低到高买

1 #1833
2
3 class Solution(object):
4     def maxIceCream(self, costs, coins):
5         """
6         :type costs: List[int]
7         :type coins: int
8         :rtype: int
9         """
10         costs.sort()
11         ans = 0
12         for i in costs:
13             coins -= i
14             if coins < 0:
15                 break
16             ans += 1
17         return ans

Uriel 2023-01-06 20:31 发表评论

[LeetCode]452. Minimum Number of Arrows to Burst Balloons (Medium) Python-2023.01.05

Uriel — Thu, 05 Jan 2023 07:49:00 GMT

�l�定一堆的�U�段范围�Q�每个线�D�i从points[i][0]~points[i][1]�Q�每�ơ射��L��一个值p�Q�若points[i][0]<=p<=points[i][1]的线�D�可以被消除�Q�问一共需要射��d��ơ可以消除所有线�D�c��贪�?br />
先对�q�个二维point list按第二维的��g��到大排序，然后从第一根线�D�开始，��击最右端的点�Q�之后的�U�段若可以cover�q�个点，则一�q�被消去

1 #452
2 #Runtime: 2320 ms (Beats 46.75%)
3 #Memory: 62.9 MB (Beats 34.32%)
4
5 class Solution(object):
6     def findMinArrowShots(self, points):
7         """
8         :type points: List[List[int]]
9         :rtype: int
10         """
11         pt_sorted = sorted(points, key = (lambda x:[x[1], x[0]]))
12         ans = 0
13         i = 0
14         while i < len(pt_sorted):
15             p = pt_sorted[i][1]
16             while i < len(pt_sorted) and pt_sorted[i][0] <= p <= pt_sorted[i][1]:
17                 i += 1
18             ans += 1
19         return ans

Uriel 2023-01-05 15:49 发表评论

[LeetCode]944. Delete Columns to Make Sorted (Medium) Python-2023.01.04

Uriel — Wed, 04 Jan 2023 10:19:00 GMT

�l�定一堆task的难度��|��每次可以完成2个或�?个难度一��L��task�Q�问一共多��次可以完成所有task�Q�贪�?br />
先统计每一�U�难度值的出现�ơ数�Q�分以下几种情况
1. 只出��C��ơ，那么�q�个task无法被单独完成，直接return -1
2. 出现mod 3=0�ơ，那么每次完成3个此�c�task
3. 出现mod 3=1�ơ，那么每次完成3个此�c�task�Q�最后剩4个此�c�task每次完成2�?br />4. 出现mod 3=2�ơ，那么每次完成3个此�c�task�Q�最后剩2个此�c�task一�ơ完�?br />

1 #944
2 #Runtime: 2137 ms (Beats 43.75%)
3 #Memory: 26.8 MB (Beats 39.58%)
4
5 class Solution(object):
6     def minimumRounds(self, tasks):
7         """
8         :type tasks: List[int]
9         :rtype: int
10         """
11         cnt = Counter(tasks)
12         ans = 0
13         for i in cnt:
14             if cnt[i] == 1:
15                 return -1
16             if cnt[i] % 3 == 0:
17                 ans += cnt[i] / 3
18             elif cnt[i] % 3 == 1:
19                 ans += 2 + (cnt[i] - 4) / 3
20             elif cnt[i] % 3 == 2:
21                 ans += 1 + (cnt[i] - 2) / 3
22         return ans

Uriel 2023-01-04 18:19 发表评论

[LeetCode]1962. Remove Stones to Minimize the Total (Medium) Python-2022.12.28

Uriel — Wed, 28 Dec 2022 06:28:00 GMT

�l�出一列数�Q�一共可以实施k个操作，每次可以��其中一个数减去floor(piles[i] / 2)�Q�问k�ơ操作之后剩下的数字和最��是多少
思�\�Q�用优先队列保存�l�过x�ơ操作之后的数字�Q�用python的heapq写�v来就很方便，每次操作直接用heapreplace把heap��的数减半替代原值即可（比先pop�Q�改��g��后再push要快�Q�beat 100%�Q?br />因�ؓheapq是最��堆�Q�所以徏堆时先将所有数取负

1 #2279
2 #Runtime: 3519 ms (Beats 100%)
3 #Memory: 26 MB (Beats 37.21%)
4
5 class Solution(object):
6     def minStoneSum(self, piles, k):
7         """
8         :type piles: List[int]
9         :type k: int
10         :rtype: int
11         """
12         hq = [-x for x in piles]
13         heapify(hq)
14         for _ in range(k):
15             heapreplace(hq, hq[0] // 2)
16         return -sum(hq)

Uriel 2022-12-28 14:28 发表评论

[LeetCode]2279. Maximum Bags With Full Capacity of Rocks (Medium) Python-2022.12.27

Uriel — Tue, 27 Dec 2022 05:42:00 GMT

有一些包�Q�每个里面已�l�装了rocks[i]的物品，每个包容量capacity[i]�Q�现在还有additionalRocks重量的物品，问最多可以有几个包被装满�Q�贪�?br />
计算每个包剩余容量，�q�且从小到大排序�Q�一个个装直到包全部装满或者additionalRocks用完卛_��

1 #2279
2 #Runtime: 836 ms (Beats 86.21%)
3 #Memory: 20.2 MB (Beats 93.10%)
4
5 class Solution(object):
6     def maximumBags(self, capacity, rocks, additionalRocks):
7         """
8         :type capacity: List[int]
9         :type rocks: List[int]
10         :type additionalRocks: int
11         :rtype: int
12         """
13         for i in range(len(capacity)):
14             capacity[i] = max(capacity[i] - rocks[i], 0)
15         capacity.sort()
16         for i in range(len(capacity)):
17             additionalRocks -= capacity[i]
18             if additionalRocks < 0:
19                 i -= 1
20                 break
21         return i + 1

Uriel 2022-12-27 13:42 发表评论

[LeetCode]2131. Longest Palindrome by Concatenating Two Letter Words (Medium) Python-2022.11.03

Uriel — Thu, 03 Nov 2022 06:43:00 GMT

�l�定一堆长度�ؓ2的字�W�串�Q�问最长可以构成多长的回文字符�?br />用python字典�l�计每一�U�长�?的字�W�串i出现的次数dict_word[i]

��长度�ؓ2的字�W�串分�ؓ两类�Q?br />�W�一�c�：ab型，即两个字母不同，那么需要找对应的ba字符�?br />

ans = ans + 4 * min(dict_word[‘ab’], dict_word[‘ba’])

�W�一�c�：aa型，即两个字母不同，如果dict_word[‘aa’]出现奇数�ơ，那么多出来的那一个只能放中间�Q�如果有不止一个aa型字�W�串�Q�且出现字数不止一�ơ出现奇敎ͼ�那正中间位置也只能放一�?div>ans = ans + 4 * (dict_word[i] // 2) + double_chr * 2 �Q�double_chr记录是否出现�q�奇数次的aa型字�W�串�Q?br />

1 #2131
2 #Runtime: 1376 ms
3 #Memory Usage: 37.8 MB
4
5 class Solution(object):
6     def longestPalindrome(self, words):
7         """
8         :type words: List[str]
9         :rtype: int
10         """
11         dict_word = {}
12         for i in words:
13             if i in dict_word:
14                 dict_word[i] += 1
15             else:
16                 dict_word[i] = 1
17         ans = 0
18         double_chr = 0
19         for i in dict_word:
20             j = i[::-1]
21             if i == j:
22                 if dict_word[i] % 2:
23                     double_chr = 1
24                 ans += 4 * (dict_word[i] // 2)
25             else:
26                 if j in dict_word:
27                     ans += 4 * min(dict_word[i], dict_word[j])
28                     dict_word[j] = 0
29         return ans + double_chr * 2

Uriel 2022-11-03 14:43 发表评论

[LeetCode]11. Container With Most Water (Medium) Python-2022.10.31

Uriel — Mon, 31 Oct 2022 10:30:00 GMT

�l�一列数�l�，代表1-len(matrix)每个位置的桶高，问设立左右两个边界之后最多能盛多��水
贪心�Q�左右两个游标分别向中间�U�d��Q�每�ơ移动桶高小的游标，更新最大水�?br />

1 #11
2 #Runtime: 1703 ms
3 #Memory Usage: 23.9 MB
4
5 class Solution(object):
6     def maxArea(self, height):
7         """
8         :type height: List[int]
9         :rtype: int
10         """
11         p1 = 1
12         p2 = len(height)
13         ans = min(height[0], height[-1]) * (p2 - p1)
14         while p1 < p2 - 1:
15             if height[p1 - 1] < height[p2 - 1]:
16                 p1 += 1
17             else:
18                 p2 -= 1
19             ans = max(ans, min(height[p1 - 1], height[p2 - 1]) * (p2 - p1))
20         return ans

Uriel 2022-10-31 18:30 发表评论

[LeetCode]121-123, 188. Best Time to Buy and Sell Stock I~IV (Easy-Medium-Hard) Python-2022.10.21

Uriel — Fri, 21 Oct 2022 23:24:00 GMT

121. Best Time to Buy and Sell Stock (Easy)

�l�一列股��h��|��问买卖不��过1�ơ的情况下最多赚多少

122. Best Time to Buy and Sell Stock III (Medium)

�l�一列股��h��|��问无限次买卖的情况下最多赚多少�Q�但手里同一时刻只能持有一份股��）

123. Best Time to Buy and Sell Stock III (Hard)

�l�一列股��h��|��问买卖不��过2�ơ的情况下最多赚多少
188. Best Time to Buy and Sell Stock IV (Hard)

�l�一列股��h��|��问买卖不��过k�ơ的情况下最多赚多少

121, 123�?88�c�M��Q�都是DP思想�Q�remain[j]�Q�已�l�买入j�ơ之后最多手头剩下的钱，profit[j]�Q�已�l�卖出j�ơ之后最多赚了多��，注意卖出前必��要先买入，188注意特判len(prices)=1的情�?/div>

122贪心�Q�预处理i和i+1天之间的价差�Q�有的赚��都加上

1 #121
2 #Runtime: 869 ms
3 #Memory Usage: 22.5 MB
4
5 class Solution(object):
6     def maxProfit(self, prices):
7         """
8         :type prices: List[int]
9         :rtype: int
10         """
11         remain = 0
12         profit = 0
13         remain = prices[0]
14         for i in range(1, len(prices)):
15             remain = min(remain, prices[i])
16             profit = max(profit, prices[i] - remain)
17         return profit

1 #122
2 #Runtime: 48 ms
3 #Memory Usage: 14.8 MB
4
5 class Solution(object):
6     def maxProfit(self, prices):
7         """
8         :type prices: List[int]
9         :rtype: int
10         """
11         profit = []
12         for i in range(len(prices) - 1):
13             profit.append(prices[i + 1] - prices[i])
14         ans = 0
15         for i in profit:
16             if i > 0:
17                 ans += i
18         return ans
19

1 #123
2 #Runtime: 1075 ms
3 #Memory Usage: 25 MB
4
5 class Solution(object):
6     def maxProfit(self, prices):
7         """
8         :type prices: List[int]
9         :rtype: int
10         """
11         remain = [0, -sys.maxint, -sys.maxint]
12         profit = [0, -sys.maxint, -sys.maxint]
13
14         for i in range(0, len(prices)):
15             for j in range(1, 3):
16                 remain[j] = max(remain[j], profit[j - 1] - prices[i])
17                 profit[j] = max(profit[j], remain[j] + prices[i])
18         return max(profit)

1 #188
2 #Runtime: 250 ms
3 #Memory Usage: 13.3 MB
4
5 class Solution(object):
6     def maxProfit(self, k, prices):
7         """
8         :type k: int
9         :type prices: List[int]
10         :rtype: int
11         """
12         remain = [-sys.maxint] * (len(prices) + 1)
13         profit = [-sys.maxint] * (len(prices) + 1)
14         remain[0] = 0
15         profit[0] = 0
16         for i in range(0, len(prices)):
17             for j in range(1, min(len(prices) + 1, k + 1)):
18                 remain[j] = max(remain[j], profit[j - 1] - prices[i])
19                 profit[j] = max(profit[j], remain[j] + prices[i])
20         return max(profit)

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