C++博客-Uriel's Corner-文章分类-贪心

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

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

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

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代表不同颜色的气球，相邻气球颜色相同的话每次可以保留其中一个，花费时间为二者needTime中间的较小值，问消除全部的相邻气球的最小总花费，贪心

#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

输出一个字符串的最大奇数子串，贪心，从最后一位向前找奇数

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二维矩阵的列，问能构成的最大的全1子矩阵有多大，贪心，先按列求每一行的prefix sum（因为行顺序不能换，所以遇到0的话要清0），然后遍历每一行，更新最大子矩阵尺寸

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

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

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

给出一列数，将其中的数分成若干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

对一列数进行reorder和decrease，使得这列数以1开始，相邻数差别不超过1，问数列里最大值是多少，贪心

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

给出每个monster的距离以及行进速度，每次装备需要1个单位时间，问最多可以灭掉几个monster，如果monster到达的时候未装备，则宣告失败。先预处理每个monster到达的时间（注意用浮点数），然后sort，看有多少monster可以在i时间内到达

#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

给出一列A和B组成的字符串，选手A和B轮流操作，每次A看到三个相连的A，则可以去掉中间的A，B看到三个相连的B，则可以去掉中间的B，如果谁先无法找到可消除的字母，则输，输出A是否能赢
每次把三个相邻的数中间一个去掉，并不会影响对手可选择的消除位置，于是直接统计三个A和B（若有四个相邻，统计两次）

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

给出一堆字符，问最少去掉几个字符可以保证每种字符出现的次数不同，用python的counter统计次数，然后用set记录已经出现过的字符频次，若有冲突，不断去掉字符直至不冲突

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

给出一个数列，每一次操作可以将其中一个数换成两个数，两数之和和原数一样，问最少几次操作可以将数列变成单调不减，贪心思想，最后一个数作为初始值，如果前一个数比他大，尽量分裂成更大更相等的几个数，不断和前一个数比直到数列头

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

将一列字符串中的字符重新排序，使得相邻字符不相同
贪心思想，用priority queue将字符按照出现次数从多到少排序，然后一次填入结果字符串，如果单种字符次数超过字符串总长度一半，则不能实现。先填充所有奇数位，然后填偶数位

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

给出一列数，找出p对数字（每个数只能最多用一次），问这p对数字两两之差之和最小多少，直接二分结果，若想两两之差小，那么就是sort之后每次选相邻的数

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

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

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

给出一堆石子的重量，分到k个包里，每个包需要i～j连续堆全部取完，每堆的cost为weights[i]+weights[j]，求不同的分配方式里面k堆的总cost最大值和最小值之差
思路参考 -> 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

给出一个数列每次可以将下标i的数-1，将下标i-1的数+1，执行此操作无限多次，使得最后得到的数列的最大值最小，求这个值
这个操作不改变数列的平均值，让最大值最小就是让数列尽可能平均，于是求数列所有的前缀的平均值里面最大的即可

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

给出一些菜品的满意值，可以选择做其中的0~所有菜，最后总的满意度计算方式为sum(time[i] * satisfaction[i])，time[i]=i是指该道菜是第i个做的，贪心，越满意的菜品越后做，这样time[i]更大
实际做的时候将菜品按满意度从大到小排序，不断累加满意度值，如果到某一时刻累加值为负，后面的菜都不用考虑了

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

给出一个0，1组成的list，要求1不能相邻放置，问是否可以再向其中插入n个1，简单贪心，从左边每个0开始，符合要求就放1，看最后能不能放置>=n个

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

给出一列数，对于奇数，可以*2，对于偶数，可以/2，问执行任意多次操作之后，这列数的最大最小值之差最小是多少

参考了：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，每个需要capacity[i]才能启动，获利profits[i]，初始拥有w capacity，问完成最多k个projects可以最多获利多少
利用heap（or优先队列）的贪心
先按照capacity从小到大对projects排序，然后从第一个project开始，如果capacity小于当前的w，则加入heap，直到capacity的要求大于当前w，然后去完成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

给一串由0和1组成的字符串，每次操作把其中一位从0变1或者从1变0，问至少几次操作可以让整个字符串变成从左至右单调增
参考了Discussion的巧妙思路->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

一些加油站构成一个环路，给出每个加油站i可以加的油量gas[i],以及从idaoi+1需要的油量cost[i]，问是否可以从某个加油站开始顺时针遍历所有加油站

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

C++版

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版

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.cppblog.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); 给出每个ice cream的价格costs[i]，一共有coins钱，问最多买多少ice cream，贪心水题，直接按costs排序从价格由低到高买

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

给定一堆的线段范围，每个线段i从points[i][0]~points[i][1]，每次射击某一个值p，若points[i][0]<=p<=points[i][1]的线段可以被消除，问一共需要射击几次可以消除所有线段。贪心

先对这个二维point list按第二维的值从小到大排序，然后从第一根线段开始，射击最右端的点，之后的线段若可以cover这个点，则一并被消去

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

给定一堆task的难度值，每次可以完成2个或者3个难度一样的task，问一共多少次可以完成所有task，贪心

先统计每一种难度值的出现次数，分以下几种情况
1. 只出现一次，那么这个task无法被单独完成，直接return -1
2. 出现mod 3=0次，那么每次完成3个此类task
3. 出现mod 3=1次，那么每次完成3个此类task，最后剩4个此类task每次完成2个
4. 出现mod 3=2次，那么每次完成3个此类task，最后剩2个此类task一次完成

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

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

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

有一些包，每个里面已经装了rocks[i]的物品，每个包容量capacity[i]，现在还有additionalRocks重量的物品，问最多可以有几个包被装满，贪心

计算每个包剩余容量，并且从小到大排序，一个个装直到包全部装满或者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

给定一堆长度为2的字符串，问最长可以构成多长的回文字符串
用python字典统计每一种长度2的字符串i出现的次数dict_word[i]

将长度为2的字符串分为两类：
第一类：ab型，即两个字母不同，那么需要找对应的ba字符串

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

第一类：aa型，即两个字母不同，如果dict_word[‘aa’]出现奇数次，那么多出来的那一个只能放中间（如果有不止一个aa型字符串，且出现字数不止一次出现奇数，那正中间位置也只能放一个

ans = ans + 4 * (dict_word[i] // 2) + double_chr * 2 （double_chr记录是否出现过奇数次的aa型字符串）

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

给一列数组，代表1-len(matrix)每个位置的桶高，问设立左右两个边界之后最多能盛多少水
贪心，左右两个游标分别向中间移动，每次移动桶高小的游标，更新最大水量

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)

给一列股票价格，问买卖不超过1次的情况下最多赚多少

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

给一列股票价格，问无限次买卖的情况下最多赚多少（但手里同一时刻只能持有一份股票）

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

给一列股票价格，问买卖不超过2次的情况下最多赚多少
188. Best Time to Buy and Sell Stock IV (Hard)

给一列股票价格，问买卖不超过k次的情况下最多赚多少

121, 123和188类似，都是DP思想，remain[j]：已经买入j次之后最多手头剩下的钱，profit[j]：已经卖出j次之后最多赚了多少，注意卖出前必须要先买入，188注意特判len(prices)=1的情况

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

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 发表评论