C++博客-Uriel's Corner-文章分类-排序

[LeetCode]1887. Reduction Operations to Make the Array Elements Equal (Medium) Python-2023.11.19

Uriel — Sun, 19 Nov 2023 12:00:00 GMT

给出一列数，每次将其中最大的数变成第二大的数，问最少几次可以把所有数变成一样，sort然后按不同数字出现次数加和

Time complexity: O(nlogn)

Space complexity: O(1)

1 #1887
2 #Runtime: 768 ms (Beats 100%)
3 #Memory: 19.2 MB (Beats 66.67%)
4
5 class Solution(object):
6     def reductionOperations(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         nums.sort()
12         nt_sum = 0
13         pre = nums[-1]
14         nt = 1
15         ans = 0
16         for i in xrange(len(nums) - 2, -1, -1):
17             if nums[i] == pre:
18                 nt += 1
19             else:
20                 nt_sum += nt
21                 ans += nt_sum
22                 nt = 1
23                 pre = nums[i]
24         return ans

Uriel 2023-11-19 20:00 发表评论

[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]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]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]23. Merge k Sorted Lists (Hard) Python-2023.03.12

Uriel — Sun, 12 Mar 2023 08:09:00 GMT

给出若干已排序的单链表，合并成一个
先遍历每个单链表，记录所有数字之后从大到小sort，之后一个个塞入链表，最后返回头指针
没想到可以Beat 100% Python submissions。。。

1 #23
2 #Runtime: 53 ms (Beats 100%)
3 #Memory: 22.3 MB (Beats 26.72%)
4
5 # Definition for singly-linked list.
6 # class ListNode(object):
7 #     def __init__(self, val=0, next=None):
8 #         self.val = val
9 #         self.next = next
10 class Solution(object):
11     def mergeKLists(self, lists):
12         """
13         :type lists: List[ListNode]
14         :rtype: ListNode
15         """
16         total = []
17         for i in lists:
18             h = i
19             while h:
20                 total.append(h.val)
21                 h = h.next
22         total = sorted(total, reverse = True)
23         head = None
24         for i in total:
25             head = ListNode(i, head)
26         return head

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

[LeetCode]912. Sort an Array (Medium) Python-2022.03.01

Uriel — Wed, 01 Mar 2023 11:01:00 GMT

实现O(nlogn)的排序，可能有重复的数

因为数据范围不超过100k，利用python的dict可以实现O(n)，但是空间复杂度就不太好看了

1 #912
2 #Runtime: 710 ms (Beats 84.97%)
3 #Memory: 27.6 MB (Beats 10.48%)
4
5 class Solution(object):
6     def sortArray(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         num_dict = defaultdict(lambda:0)
12         min_num = 50001
13         max_num = -50001
14         for i in nums:
15             num_dict[i] += 1
16             min_num = min(min_num, i)
17             max_num = max(max_num, i)
18         ans = []
19         for i in range(min_num, max_num + 1):
20             ans.extend([i] * num_dict[i])
21         return ans

Uriel 2023-03-01 19:01 发表评论

[LeetCode]4. Median of Two Sorted Arrays (Hard) Python-2022.10.25/2023.09.21

Uriel — Tue, 25 Oct 2022 11:25:00 GMT

给两个已经排序的list，求中位数

直接二分结果，然后在两个list分别二分确定位置，到达中间位置之后再精确求中位数并输出，输出那里调了几次，WA了几次，然后代码就整得又臭又长 ==||
AC之后看Discussion，原来直接sort完求中位数就能过啊，我这样二分反而慢，不科学啊，这可是标为Hard的题啊

直接sort

1 #4
2 #Runtime: 54 ms (Beats 92.77%)
3 #Memory: 13.3 MB (Beats 88.11%)
4
5 class Solution(object):
6     def findMedianSortedArrays(self, nums1, nums2):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :rtype: float
11         """
12         nums = nums1 + nums2
13         nums.sort()
14         n = len(nums)
15         if n % 2 == 0:
16             return 0.5 * (nums[(n // 2) - 1] + nums[(n // 2)])
17         return nums[(n - 1) // 2]

二分

1 #4
2 #Runtime: 244 ms
3 #Memory Usage: 13.5 MB
4
5 class Solution(object):
6     def findMedianSortedArrays(self, nums1, nums2):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :rtype: float
11         """
12         if len(nums1) == 0:
13             if len(nums2) % 2 == 0:
14                 return (float(nums2[int(len(nums2)/2) - 1]) + float(nums2[int(len(nums2)/2)])) / 2
15             else:
16                 return float(nums2[int(len(nums2)/2)])
17         if len(nums2) == 0:
18             if len(nums1) % 2 == 0:
19                 return (float(nums1[int(len(nums1)/2) - 1]) + float(nums1[int(len(nums1)/2)])) / 2
20             else:
21                 return float(nums1[int(len(nums1)/2)])
22         l = float(min(nums1[0], nums2[0]))
23         r = float(max(nums1[-1], nums2[-1]))
24         l1 = 0
25         r1 = len(nums1)
26         l2 = 0
27         r2 = len(nums2)
28         if l == r:
29             return float(l)
30         while r - l > 0.000001:
31             mid = (l + r) / 2
32             mid1 = 0
33             mid2 = 0
34             ll1 = l1
35             rr1 = r1
36             while ll1 < rr1:
37                 mid1 = int((ll1 + rr1) / 2)
38                 if nums1[mid1 - 1] < mid:
39                     ll1 = mid1 + 1
40                 else:
41                     rr1 = mid1
42             mid1 = int((ll1 + rr1) / 2)
43             f1 = 0
44             if nums1[mid1 - 1] > mid:
45                 mid1 = max(0, mid1 - 0.5)
46             elif nums1[mid1 - 1] == mid:
47                 f1 = 1
48             else:
49                 mid1 = min(r1, mid1 + 0.5)
50             ll2 = l2
51             rr2 = r2
52             while ll2 < rr2:
53                 mid2 = int((ll2 + rr2) / 2)
54                 if nums2[mid2 - 1] < mid:
55                     ll2 = mid2 + 1
56                 else:
57                     rr2 = mid2
58             mid2 = int((ll2 + rr2) / 2)
59             f2 = 0
60             if nums2[mid2 - 1] > mid:
61                 mid2 = max(0, mid2 - 0.5)
62             elif nums2[mid2 - 1] == mid:
63                 f2 = 1
64             else:
65                 mid2 = min(r2, mid2 + 0.5)
66             if f1 == 1 and f2 == 1:
67                 return (nums1[mid1 - 1] + nums2[mid2 - 1]) / 2.0
68             if f1 == 0 and f2 == 0 and 2 * (int(mid1) + int(mid2)) == r1 + r2:
69                 a = []
70                 b = []
71                 if int(mid1) - 1 >= 0:
72                     a.append(nums1[int(mid1) - 1])
73                 if int(mid2) - 1 >= 0:
74                     if len(a) > 0:
75                         a[0] = max(a[0], nums2[int(mid2) - 1])
76                     else:
77                         a.append(nums2[int(mid2) - 1])
78                 if int(mid1) < len(nums1):
79                     b.append(nums1[int(mid1)])
80                 if int(mid2) < len(nums2):
81                     if len(b) > 0:
82                         b[0] = min(b[0], nums2[int(mid2)])
83                     else:
84                         b.append(nums2[int(mid2)])
85                 return (a[0] + b[0]) / 2.0
86             if f1 == 0 and f2 == 1 and 2 * (int(mid1) + int(mid2)) == r1 + r2:
87                 return nums2[int(mid2) - 1]
88             if f1 == 1 and f2 == 0 and 2 * (int(mid1) + int(mid2)) == r1 + r2:
89                 return nums1[int(mid1) - 1]
90             if 2 * (int(mid1) + int(mid2)) < r1 + r2:
91                 l = mid + 0.0000001
92             else:
93                 r = mid - 0.0000001
94         return mid

Uriel 2022-10-25 19:25 发表评论