C++博客-Uriel's Corner-文章分类-二分.三分

[LeetCode]2251. Number of Flowers in Full Bloom (Hard) Python3-2023.10.11

Uriel — Mon, 06 Nov 2023 17:53:00 GMT

给出每个花的开花时间（起点终点），输出people数组每个人到达时有多少花在开。线段树、扫描线、二分

1 #2251
2 #Runtime: 1083 ms (Beats 15.71%)
3 #Memory: 44.7 MB (Beats 32.83%)
4
5 class Solution:
6     def fullBloomFlowers(self, flowers: List[List[int]], people: List[int]) -> List[int]:
7         st = sorted(flowers, key=lambda x:x[0])
8         ed = sorted(flowers, key=lambda x:x[1])
9         ans = []
10         for x in people:
11             i = bisect_left(ed, x, key=lambda x:x[1])
12             j = bisect_right(st, x, key=lambda x:x[0])
13             ans.append(j - i)
14         return ans

Uriel 2023-11-07 01:53 发表评论

[LeetCode]1095. Find in Mountain Array (Hard) Python-2023.10.12

Uriel — Thu, 12 Oct 2023 13:31:00 GMT

给出一个先单调上升后单调下降的数组，查询某个数，若不存在输出-1
先三分求极值，再分左右两段二分查找

1 #1095
2 #Runtime: 32 ms (Beats 61.2%)
3 #Memory: 14.5 MB (Beats 5.8%)
4
5 # """
6 # This is MountainArray's API interface.
7 # You should not implement it, or speculate about its implementation
8 # """
9 #class MountainArray(object):
10 #    def get(self, index):
11 #        """
12 #        :type index: int
13 #        :rtype int
14 #        """
15 #
16 #    def length(self):
17 #        """
18 #        :rtype int
19 #        """
20
21 class Solution(object):
22     def findInMountainArray(self, target, mountain_arr):
23         """
24         :type target: integer
25         :type mountain_arr: MountainArray
26         :rtype: integer
27         """
28         def b_search(l, r, di):
29             while l < r:
30                 mid = (l + r) // 2
31                 if di == 0:
32                     if mountain_arr.get(mid) < target:
33                         l = mid + 1
34                     else:
35                         r = mid
36                 else:
37                     if mountain_arr.get(mid) > target:
38                         l = mid + 1
39                     else:
40                         r = mid
41             return l
42
43         l, r = 0, mountain_arr.length() - 1
44         eps = 1e-6
45         while l < r:
46             mid = (l + r) // 2
47             midmid = (mid + r) // 2
48             if mountain_arr.get(mid) >= mountain_arr.get(midmid):
49                 r = midmid
50             else:
51                 l = mid + 1
52         idx = b_search(0, l, 0)
53         if mountain_arr.get(idx) == target:
54             return idx
55         idx = b_search(l + 1, mountain_arr.length() - 1, 1)
56         if mountain_arr.get(idx) == target:
57             return idx
58         return -1

Uriel 2023-10-12 21:31 发表评论

[LeetCode]34. Find First and Last Position of Element in Sorted Array (Medium) Python-2023.10.09

Uriel — Mon, 09 Oct 2023 10:56:00 GMT

给出一列一排序的数组，问某个数target在里面第一次和最后一次出现的位置，二分，用python的bisect很方便

#34
#Runtime: 67 ms (Beats 6.68%)
#Memory: 14.4 MB (Beats 65.32%)

class Solution(object):
    def searchRange(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        l = bisect.bisect_left(nums, target)
        r = bisect.bisect_right(nums, target)
        if l > r - 1:
            return [-1, -1]
        return [l, r - 1]

Uriel 2023-10-09 18:56 发表评论

[LeetCode]1337. The K Weakest Rows in a Matrix (Easy) Python-2023.06.18

Uriel — Mon, 18 Sep 2023 08:21:00 GMT

给出二维0-1矩阵，每行都由连续的1之后全0，输出含1最少的k行，二分确定每行0-1分隔的位置，heapq存每行的1的数量

1 #1337
2 #Runtime: 71 ms (Beats 88.26%)
3 #Memory: 13.6 MB (Beats 61.50%)
4
5 class Solution(object):
6     def kWeakestRows(self, mat, k):
7         """
8         :type mat: List[List[int]]
9         :type k: int
10         :rtype: List[int]
11         """
12         def bi_sect(x):
13             l, r = 0, len(mat[0])
14             while l < r:
15                 mid = (l + r) // 2
16                 if mat[x][mid] == 1:
17                     l = mid + 1
18                 else:
19                     r = mid
20             return l
21
22         hq = []
23         ans = []
24         for r in xrange(len(mat)):
25             p = bi_sect(r)
26             heapq.heappush(hq, (p, r))
27         for _ in xrange(k):
28             ans.append(heappop(hq)[1])
29         return ans

Uriel 2023-09-18 16:21 发表评论

[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]33. Search in Rotated Sorted Array (Medium) Python-2023.08.08

Uriel — Tue, 08 Aug 2023 08:55:00 GMT

一个递增的数组从中间切断，前面一半append到数组后面，问某个数target在不在数组内，二分，每次判断mid实在左边的那一段递增数组还是右边一段

1 #33
2 #Runtime: 19 ms (Beats 92.37%)
3 #Memory: 13.5 MB (Beats 57.32%)
4
5 class Solution(object):
6     def search(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         l, r = 0, len(nums) - 1
13         while l <= r:
14             mid = (l + r) // 2
15             if nums[mid] == target:
16                 return mid
17             if nums[mid] >= nums[0]:
18                 if nums[0] <= target and nums[mid] > target:
19                     r = mid - 1
20                 else:
21                     l = mid + 1
22             else:
23                 if nums[mid] < target and nums[-1] >= target:
24                     l = mid + 1
25                 else:
26                     r = mid - 1
27         return -1

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

[LeetCode]74. Search a 2D Matrix (Medium) C++/Python-2014.01.09/2023.08.07

Uriel — Mon, 07 Aug 2023 06:35:00 GMT

给出一个二维数字矩阵，每行从左到右递增，下一行第一个数大于上一行最后一个数，问某个数字target是否在矩阵里

方法一：当成一个1D递增向量，二分，O(log(N*M))
Python实现

1 #74
2 #Runtime: 19 ms (Beats 97.2%)
3 #Memory: 13.6 MB (Beats 95.32%)
4
5 class Solution(object):
6     def searchMatrix(self, matrix, target):
7         """
8         :type matrix: List[List[int]]
9         :type target: int
10         :rtype: bool
11         """
12         l, r = 0, len(matrix[0]) * len(matrix) - 1
13         while l < r:
14             mid = (l + r) // 2
15             if matrix[mid // len(matrix[0])][mid % len(matrix[0])] < target:
16                 l = mid + 1
17             else:
18                 r = mid
19         return matrix[l // len(matrix[0])][l % len(matrix[0])] == target

方法二：先确定在哪一行，再扫描该行所有列，O(N+M)
C++实现

1 //74
2 //Runtime: 56 ms (Beats 16.15%)
3
4 class Solution {
5 public:
6     bool searchMatrix(vectorint> > &matrix, int target) {
7         int n = matrix.size();
8         int m = matrix[0].size();
9         int i, j;
10         for(i = 0; i < n; ++i) {
11             if(matrix[i][0] > target) {
12                 --i;
13                 break;
14             }
15             if(i == n - 1) break;
16         }
17         if(i < 0) return false;
18         for(j = 0; j < m; ++j) {
19             if(matrix[i][j] == target) return true;
20         }
21         return false;
22     }
23 };

Uriel 2023-08-07 14:35 发表评论

[LeetCode]2141. Maximum Running Time of N Computers (Hard) Python-2023.07.27

Uriel — Thu, 27 Jul 2023 10:34:00 GMT

有一些电池，每个电池可以使用batteries[i]时间，问要同时运行n台机器，每台机器需要一个电池，最多可以运行多久，二分

一开始r取小了点，WA*1

1 #2141
2 #Runtime: 2010 ms (Beats 33.33%)
3 #Memory: 25.1 MB (Beats 100%)
4
5 class Solution(object):
6     def maxRunTime(self, n, batteries):
7         """
8         :type n: int
9         :type batteries: List[int]
10         :rtype: int
11         """
12         l, r = 0, sum(batteries) // n + 1
13         while l <= r:
14             mid = (l + r) // 2
15             if sum(min(mid, b) for b in batteries) >= n * mid:
16                 l = mid + 1
17             else:
18                 r = mid - 1
19         return r

Uriel 2023-07-27 18:34 发表评论

[LeetCode]852. Peak Index in a Mountain Array (Medium) Python-2023.07.26

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

给出每个office的距离，以及需要再hour时间内依次去到所有office，去每个office的时间是dis[i]/hour向上取整，二分，注意r要开大点，以及一开始要特判无论多块都无法按时arrive的情况

#852
#Runtime: 2487 ms (Beats 90.91%)
#Memory: 25 MB (Beats 72.73%)

class Solution(object):
    def minSpeedOnTime(self, dist, hour):
        """
        :type dist: List[int]
        :type hour: float
        :rtype: int
        """
        eps = 1e-6
        l, r = 1, 1000000000
        if hour <= len(dist) - 1:
            return -1
        while l < r:
            mid = (l + r) // 2
            t = 0
            for x in dist[:-1]:
                t += x // mid
                if x % mid:
                    t += 1
            t += 1.0 * dist[-1] / mid
            if t <= hour:
                r = mid
            else:
                l = mid + 1
        return l

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

[LeetCode]852. Peak Index in a Mountain Array (Medium) Python-2023.07.25

Uriel — Tue, 25 Jul 2023 10:35:00 GMT

二分法求先单调增然后单调减的数列的最大值下标

1 #852
2 #Runtime: 537 ms (Beats 55.42%)
3 #Memory: 25.7 MB (Beats 90.39%)
4
5 class Solution(object):
6     def peakIndexInMountainArray(self, arr):
7         """
8         :type arr: List[int]
9         :rtype: int
10         """
11         l, r = 0, len(arr) - 1
12         while l < r:
13             mid = (l + r) // 2
14             if arr[mid] < arr[mid + 1]:
15                 l = mid + 1
16             else:
17                 r = mid
18         return r

Uriel 2023-07-25 18:35 发表评论

[LeetCode]50. Pow(x, n) (Medium) Python-2023.07.24

Uriel — Mon, 24 Jul 2023 11:38:00 GMT

实现x的n次方计算，二分

1 #50
2 #Runtime: 14 ms (Beats 83.42%)
3 #Memory: 13.2 MB (Beats 69.77%)
4
5 class Solution(object):
6     def myPow(self, x, n):
7         """
8         :type x: float
9         :type n: int
10         :rtype: float
11         """
12
13         def cal(x, n):
14             if n == 0:
15                 return 1.0
16             if n % 2:
17                 return cal(x * x, n // 2) * x
18             else:
19                 return cal(x * x, n // 2)
20
21         if n < 0:
22             return 1.0 / cal(x, -n)
23         return cal(x, n)

Uriel 2023-07-24 19:38 发表评论

[LeetCode]1751. Maximum Number of Events That Can Be Attended II (Hard) Python-2023.07.15

Uriel — Sat, 15 Jul 2023 10:04:00 GMT

有一堆event，每个event有开始和结束时间以及value，最多参加k个event问最多获得多少value，DFS+二分查找下一个可以参与的开始时间最早的event

1 #1751
2 #Runtime: 999 ms (Beats 60%)
3 #Memory: 133.9 MB (Beats 20%)
4
5 class Solution(object):
6     def maxValue(self, events, k):
7         """
8         :type events: List[List[int]]
9         :type k: int
10         :rtype: int
11         """
12         n = len(events)
13         events.sort(key=lambda x: x[0])
14         dp = [[-1] * n for _ in range(k + 1)]
15
16         def DFS(idx, cnt):
17             if cnt == 0 or idx == len(events):
18                 return 0
19             if dp[cnt][idx] != -1:
20                 return dp[cnt][idx]
21             dp[cnt][idx] = max(DFS(idx + 1, cnt), events[idx][2] + DFS(bsearch(events[idx][1]), cnt - 1))
22             return dp[cnt][idx]
23
24         def bsearch(x):
25             l, r = 0, len(events) - 1
26             while l <= r:
27                 mid = (l + r + 1) // 2
28                 if events[mid][0] <= x:
29                     l = mid + 1
30                 else:
31                     r = mid - 1
32             return l
33
34         return DFS(0, k)

Uriel 2023-07-15 18:04 发表评论

[LeetCode]209. Minimum Size Subarray Sum (Medium) Python-2023.07.06

Uriel — Thu, 06 Jul 2023 16:27:00 GMT

给定一个数列，问其中最少多少个连续元素之和可以大于target，预处理前缀和，然后二分答案判断是否可行，复杂度O(nlogn)

1 #209
2 #Runtime: 241 ms (Beats 10.50%)
3 #Memory: 24.1 MB (Beats 5.56%)
4
5 class Solution(object):
6     def minSubArrayLen(self, target, nums):
7         """
8         :type target: int
9         :type nums: List[int]
10         :rtype: int
11         """
12         pre_sum = [0]
13         for i in range(0, len(nums)):
14             pre_sum.append(pre_sum[-1] + nums[i])
15         if pre_sum[-1] < target:
16             return 0
17         l, r = 1, len(pre_sum)
18         while l < r:
19             mid = (l + r) // 2
20             ok = False
21             for i in range(mid, len(pre_sum)):
22                 if pre_sum[i] - pre_sum[i - mid] >= target:
23                     ok = True
24                     break
25             if ok:
26                 r = mid
27             else:
28                 l = mid + 1
29         return r

Uriel 2023-07-07 00:27 发表评论

[LeetCode]1970. Last Day Where You Can Still Cross (Hard) Python-2023.06.30

Uriel — Sat, 01 Jul 2023 06:41:00 GMT

一个row行col列的二维矩阵，初始所有元素为0，代表均可以走，每天有一个格子变为1，不可走，问最迟第几天可以依旧从第一行走到最后一行（具体从第几列开始，走向第几列无要求），可以四个方向走
二分答案+DFS确认是否可达

1 #1970
2 #Runtime: 3361 ms (Beats 85.71%)
3 #Memory: 39.9 MB (Beats 14.29%)
4
5 class Solution(object):
6     def latestDayToCross(self, row, col, cells):
7         """
8         :type row: int
9         :type col: int
10         :type cells: List[List[int]]
11         :rtype: int
12         """
13         d = [[0, 1], [0, -1], [-1, 0], [1, 0]]
14         def DFS(grid, r, c):
15             if 0 <= r < row and 0 <= c < col and grid[r][c] == 0:
16                 if r == row - 1:
17                     return True
18                 grid[r][c] = -1
19                 for x in d:
20                     tr = r + x[0]
21                     tc = c + x[1]
22                     if DFS(grid, tr, tc):
23                         return True
24             return False
25
26         def ok(x):
27             grid = [[0] * col for _ in range(row)]
28             for i in range(x):
29                 grid[cells[i][0] - 1][cells[i][1] - 1] = 1
30             for i in range(col):
31                 if grid[0][i] == 0 and DFS(grid, 0, i):
32                     return True
33             return False
34
35         l = 1
36         r = len(cells)
37         while l < r:
38             mid = (l + r) // 2 + (l + r) % 2
39             if ok(mid):
40                 l = mid
41             else:
42                 r = mid - 1
43         return l
44

Uriel 2023-07-01 14:41 发表评论

[LeetCode]2448. Minimum Cost to Make Array Equal (Hard) Python-2023.06.21

Uriel — Wed, 21 Jun 2023 14:08:00 GMT

给出一列数以及每个位置增/减1需要的cost，问最少多少cost可以让整列数变成一样的。因为最后相同的数必定在原数列最小值和最大值之间，而且总cost会是个U型曲线，所以二分结果找最小值
参考了Discussion -> https://leetcode.com/problems/minimum-cost-to-make-array-equal/solutions/3663660/binary-search-video-java-c-python/

1 #2448
2 #Runtime: 748 ms (Beats 42.86%)
3 #Memory: 24.8 MB (Beats 71.43%)
4
5 class Solution(object):
6     def minCost(self, nums, cost):
7         """
8         :type nums: List[int]
9         :type cost: List[int]
10         :rtype: int
11         """
12         def cal(m):
13             t = 0
14             for i in range(len(nums)):
15                 t += abs(nums[i] - m) * cost[i]
16             return t
17
18         l, r = nums[0], nums[0]
19         for i in nums:
20             l = min(l, i)
21             r = max(r, i)
22         print(l)
23         print(r)
24         ans = 0
25         while l < r:
26             mid = (l + r) // 2
27             cost1 = cal(mid)
28             cost2 = cal(mid + 1)
29             if cost1 > cost2:
30                 l = mid + 1
31                 ans = cost2
32             else:
33                 r = mid
34                 ans = cost1
35         return ans

Uriel 2023-06-21 22:08 发表评论

[LeetCode]1187. Make Array Strictly Increasing (Hard) Python-2023.06.17

Uriel — Sat, 17 Jun 2023 10:40:00 GMT

给出两个数列arr1和arr2，可以进行操作将arr1[i]换为arr2[j]，求问最少操作几次可以让arr1变为严格递增数列，如果不存在输出-1，DP+二分搜索+memorization
参考了Discussion-> https://leetcode.com/problems/make-array-strictly-increasing/solutions/2290360/python-detailed-explanation-intution-explained-dp-clear-and-concise/

1 #1187
2 #Runtime: 4197 ms (Beats 25%)
3 #Memory: 193.2 MB (Beats 25%)
4
5 class Solution(object):
6     def makeArrayIncreasing(self, arr1, arr2):
7         """
8         :type arr1: List[int]
9         :type arr2: List[int]
10         :rtype: int
11         """
12         n1 = len(arr1)
13         n2 = len(arr2)
14         arr2.sort()
15         dp = {}
16
17         def cal(i, j, pre):
18             if i == n1:
19                 return 0
20             if (i, j, pre) in dp:
21                 return dp[(i, j, pre)]
22             k = bisect.bisect_right(arr2[j:], pre) + j
23             if k == n2:
24                 ans = float('inf')
25             else:
26                 ans = cal(i + 1, k + 1, arr2[k]) + 1
27             if arr1[i] > pre:
28                 ans = min(ans, cal(i + 1, j, arr1[i]))
29             dp[(i, j, pre)] = ans
30             return ans
31
32         ans = cal(0, 0, -float('inf'))
33         return ans if ans != float('inf') else -1

Uriel 2023-06-17 18:40 发表评论

[LeetCode]1146. Snapshot Array (Medium) Python-2023.06.11

Uriel — Sun, 11 Jun 2023 10:12:00 GMT

模拟一个支持不断做snapshot并且可以查询第i次snapshot时数组某个index的数值，数组中的所有数值都支持无限次set，并且由于memory限制，不能直接存储每一次snapshot的数组所有元素
参考了Discussion思路->https://leetcode.com/problems/snapshot-array/solutions/3623538/simple-java-c-python-easy-to-understand/

1 #1146
2 #Runtime: 706 ms (Beats 30.51%)
3 #Memory: 45.6 MB (Beats 66.10%)
4
5 class SnapshotArray(object):
6
7     def __init__(self, length):
8         """
9         :type length: int
10         """
11         self.cur_arr = [0] * length
12         self.his_arr = [[0] for _ in range(length)]
13         self.modifed_idx_list = set()
14         self.snap_id = 0
15         self.snap_id_arr = [[-1] for _ in range(length)]
16
17
18     def set(self, index, val):
19         """
20         :type index: int
21         :type val: int
22         :rtype: None
23         """
24         if self.his_arr[index][-1] == val:
25             if index in self.modifed_idx_list:
26                 self.modifed_idx_list.remove(index)
27             return
28         self.cur_arr[index] = val
29         if index not in self.modifed_idx_list:
30             self.modifed_idx_list.add(index)
31
32
33     def snap(self):
34         """
35         :rtype: int
36         """
37         for i in self.modifed_idx_list:
38             self.snap_id_arr[i].append(self.snap_id)
39             self.his_arr[i].append(self.cur_arr[i])
40         self.modifed_idx_list.clear()
41         self.snap_id += 1
42         return self.snap_id - 1
43
44
45     def get(self, index, snap_id):
46         """
47         :type index: int
48         :type snap_id: int
49         :rtype: int
50         """
51         arr = self.snap_id_arr[index]
52         l, r = 1, len(arr)
53         while l < r:
54             mid = (l + r) // 2
55             if arr[mid] <= snap_id:
56                 l = mid + 1
57             else:
58                 r = mid
59         return self.his_arr[index][l - 1]
60
61
62
63 # Your SnapshotArray object will be instantiated and called as such:
64 # obj = SnapshotArray(length)
65 # obj.set(index,val)
66 # param_2 = obj.snap()
67 # param_3 = obj.get(index,snap_id)

Uriel 2023-06-11 18:12 发表评论

[LeetCode]744. Find Smallest Letter Greater Than Target (Easy) Python-2023.06.09

Uriel — Fri, 09 Jun 2023 07:28:00 GMT

给出一个字符组成的已从小到大排序的list和一个target字符，问list中第一个比target大的字符是什么，若不存在，输出list第一个字符，二分的简单应用

手写二分：

1 #744
2 #Runtime: 83 ms (Beats 49.15%)
3 #Memory: 15.2 MB (Beats 72.73%)
4
5 class Solution(object):
6     def nextGreatestLetter(self, letters, target):
7         """
8         :type letters: List[str]
9         :type target: str
10         :rtype: str
11         """
12         def b_search(ch):
13             l = 0
14             r = len(letters) - 1
15             while l < r:
16                 mid = (l + r) // 2
17                 if letters[mid] <= target:
18                     l = mid + 1
19                 else:
20                     r = mid
21             return l
22         idx = b_search(target)
23
24         if letters[idx] > target:
25             return letters[idx]
26         return letters[0]

用python自带二分函数；

1 #744
2 #Runtime: 80 ms (Beats 66.76%)
3 #Memory: 15.2 MB (Beats 93.75%)
4
5 class Solution(object):
6     def nextGreatestLetter(self, letters, target):
7         """
8         :type letters: List[str]
9         :type target: str
10         :rtype: str
11         """
12         idx = bisect.bisect_right(letters, target)
13
14         if idx < len(letters):
15             return letters[idx]
16         return letters[0]

Uriel 2023-06-09 15:28 发表评论

[LeetCode]1351. Count Negative Numbers in a Sorted Matrix (Easy) Python-2023.06.08

Uriel — Thu, 08 Jun 2023 05:31:00 GMT

一个二维矩阵，从左到右，总上到下数字不增，求矩阵中负数有多少，水题

思路一：设个游标，记录当前行非负数有几个

1 #1351
2 #Runtime: 95 ms (Beats 68.82%)
3 #Memory: 14.5 MB (Beats 73.12%)
4
5 class Solution(object):
6     def countNegatives(self, grid):
7         """
8         :type grid: List[List[int]]
9         :rtype: int
10         """
11         pos = len(grid[0])
12         ans = 0
13         for i in range(len(grid)):
14             for j in range(pos):
15                 if grid[i][j] < 0:
16                     pos = j
17                     break
18             ans += len(grid[0]) - pos
19         return ans

思路二：每行二分求位置（复杂度更低，但这题数据估计很水，所以反而慢）

1 #1351
2 #Runtime: 102 ms (Beats 25.81%)
3 #Memory: 14.5 MB (Beats 40.86%)
4
5 class Solution(object):
6     def countNegatives(self, grid):
7         """
8         :type grid: List[List[int]]
9         :rtype: int
10         """
11         def b_search(i):
12             l = 0
13             r = len(grid[i])
14             while l < r:
15                 mid = (l + r) // 2
16                 if grid[i][mid] >= 0:
17                     l = mid + 1
18                 else:
19                     r = mid
20             return l
21
22         ans = 0
23         for i in range(len(grid)):
24             ans += len(grid[0]) - b_search(i)
25         return ans

Uriel 2023-06-08 13:31 发表评论

[LeetCode]1964. Find the Longest Valid Obstacle Course at Each Position (Hard) Python-2023.05.07

Uriel — Sun, 07 May 2023 11:34:00 GMT

给出一串数，对于每一位，输出从第一个数到当前数的最长不降子序列长度，巧妙利用stack，参考了discussion
维护一个单调不降的stk，对于每一位的数字，二分stk，若该数字比所有stk里的数都大，则append到末尾，否则替换stk里位于该数右边的一个数（因为要求单调不降而不是单调增），二分直接用python的bisect_right

1 #1964
2 #Runtime: 1442 ms (Beats 33.33%)
3 #Memory: 32 MB (Beats 100%)
4
5 class Solution(object):
6     def longestObstacleCourseAtEachPosition(self, obstacles):
7         """
8         :type obstacles: List[int]
9         :rtype: List[int]
10         """
11         stk, ans = [], []
12         for i in obstacles:
13             j = bisect_right(stk, i)
14             if j == len(stk):
15                 stk.append(i)
16             else:
17                 stk[j] = i
18             ans.append(j + 1)
19         return ans

Uriel 2023-05-07 19:34 发表评论

[LeetCode]2300. Successful Pairs of Spells and Potions (Medium) Python-2023.04.02

Uriel — Sun, 02 Apr 2023 09:26:00 GMT

给出一个数列spells和一个数列potions，用spells里面每个数依次乘以potions里面每个数，输出和spells等长的数列，每个值等于用spells里面每个数乘以potions每个数得到的length(potions)个数里面大于等于给定值success的数量
先对potions按从小到大排序，然后对于spells里面每个数，二分第一个符合大于等于success的数的位置
注意边界值

1 #2300
2 #Runtime: 1082 ms (Beats 100%)
3 #Memory: 37.5 MB (Beats 38.71%)
4
5 class Solution(object):
6     def successfulPairs(self, spells, potions, success):
7         """
8         :type spells: List[int]
9         :type potions: List[int]
10         :type success: int
11         :rtype: List[int]
12         """
13         potions.sort()
14         ans = []
15         for sp in spells:
16             ans.append(len(potions) - bisect_left(potions, ceil(1.0 * success / sp)))
17         return ans

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

[LeetCode]704. Binary Search (Easy) Python-2023.04.01

Uriel — Sat, 01 Apr 2023 08:20:00 GMT

实现二分查找，大水题

1 #704
2 #Runtime: 178 ms (Beats 94.20%)
3 #Memory: 14.8 MB (Beats 31.81%)
4
5 class Solution(object):
6     def search(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         l = 0
13         r = len(nums)
14         while l < r:
15             mid = (l + r) // 2
16             if nums[mid] == target:
17                 return mid
18             if nums[mid] < target:
19                 l = mid + 1
20             else:
21                 r = mid
22         return -1

Uriel 2023-04-01 16:20 发表评论

[LeetCode]875. Koko Eating Bananas (Medium) Python-2023.03.08

Uriel — Thu, 09 Mar 2023 13:53:00 GMT

有一堆香蕉，每堆piles[i]个，每小时吃同一堆的<=k个，求最小的k使得这堆香蕉能在h时间内吃完，简单而分，注意下限选1

1 #875
2 #Runtime: 379 ms (Beats 80.86%)
3 #Memory: 14.7 MB (Beats 56.32%)
4
5 class Solution(object):
6     def minEatingSpeed(self, piles, h):
7         """
8         :type piles: List[int]
9         :type h: int
10         :rtype: int
11         """
12         l = 1
13         r = max(piles)
14         while l < r:
15             mid = (l + r) // 2
16             t = 0
17             for i in piles:
18                 t += ceil(i*1.0 / mid)
19             if t > h:
20                 l = mid + 1
21             else:
22                 r = mid
23
24         return l

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

[LeetCode]2187. Minimum Time to Complete Trips (Medium) Python-2023.03.07

Uriel — Wed, 08 Mar 2023 11:19:00 GMT

给出每个公交车完成一次trip所需时间time[i]，以及所有需要完成的trip数totalTrips，问最少多久能完成所有trips，同一时刻可以派出任意辆车
直接二分结果

1 #2187
2 #Runtime: 2092 ms (Beats 65.38%)
3 #Memory: 24.8 MB (Beats 46.15%)
4
5 class Solution(object):
6     def minimumTime(self, time, totalTrips):
7         """
8         :type time: List[int]
9         :type totalTrips: int
10         :rtype: int
11         """
12         l = 0
13         r = totalTrips * time[0]
14         while l < r:
15             mid = (l + r) // 2
16             tr = 0
17             for i in time:
18                 tr += mid // i
19             if tr < totalTrips:
20                 l = mid + 1
21             else:
22                 r = mid
23         return l

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

[LeetCode]1011. Capacity To Ship Packages Within D Days (Medium) Python-2023.02.22

Uriel — Wed, 22 Feb 2023 14:28:00 GMT

给出所有货物的重量weights，以及需要在days天内运输完，求运载量最少需要多少，运输货物需要按weights顺序进行

因为货物的传输是确定顺序的所以比较简单，二分答案，每次判断是否能在days天内运输完即可，二分的下限是weights的最大值，上限是weights之和

1 #1011
2 #Runtime: 400 ms (Beats 51.78%)
3 #Memory: 15.4 MB (Beats 32.99%)
4
5 class Solution(object):
6     def shipWithinDays(self, weights, days):
7         """
8         :type weights: List[int]
9         :type days: int
10         :rtype: int
11         """
12         l = max(weights)
13         r = sum(weights)
14
15         def check(cap):
16             t = 1
17             c = 0
18             for wi in weights:
19                 if c + wi > cap:
20                     t += 1
21                     c = 0
22                 c += wi
23             if t <= days:
24                 return True
25             return False
26
27
28         while l < r:
29             mid = (l + r) // 2
30             if check(mid):
31                 r = mid
32             else:
33                 l = mid + 1
34         return r

Uriel 2023-02-22 22:28 发表评论

[LeetCode]540. Single Element in a Sorted Array (Medium) Python-2023.02.21

Uriel — Tue, 21 Feb 2023 09:22:00 GMT

一列已经排序的list，其中除了一个数只出现一次，别的数都出现恰好两次，求如何用O(1)空间复杂度和O(logn)时间复杂度内找出这个数，看这个复杂度就知是二分，具体思路有参考Discussion: https://leetcode.com/problems/single-element-in-a-sorted-array/solutions/3212178/day-52-binary-search-easiest-beginner-friendly-sol/?orderBy=hot

1 #540
2 #Runtime: 134 ms (Beats 72.61%)
3 #Memory: 20.6 MB (Beats 26.56%)
4
5 class Solution(object):
6     def singleNonDuplicate(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         l = 0
12         r = len(nums) - 1
13         while l < r:
14             mid = (l + r) // 2
15             if mid % 2:
16                 mid -= 1
17             if nums[mid] == nums[mid + 1]:
18                 l = mid + 2
19             else:
20                 r = mid
21         return nums[l]

Uriel 2023-02-21 17:22 发表评论

[LeetCode]35. Search Insert Position (Easy) Python-2023.02.20

Uriel — Mon, 20 Feb 2023 12:11:00 GMT

计算插入一个新数到已经按升序排序的列表中，返回插入位置，直接调用python的bisect_left()或者手写个二分

Python bisect库函数版：

1 #35
2 #Runtime: 33 ms (Beats 67.74%)
3 #Memory: 14.2 MB (Beats 31.43%)
4
5 class Solution(object):
6     def searchInsert(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         return bisect.bisect_left(nums, target)

手写二分：

1 #35
2 #Runtime: 32 ms (Beats 73.34%)
3 #Memory: 14.2 MB (Beats 60.52%)
4
5 class Solution(object):
6     def searchInsert(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         for i in range(0, len(nums)):
13             if nums[i] == target:
14                 return i
15             if nums[i] > target:
16                 return i
17         return len(nums)

Uriel 2023-02-20 20:11 发表评论

[LeetCode]2389. Longest Subsequence With Limited Sum (Easy) Python-2022.12.25

Uriel — Sun, 25 Dec 2022 11:08:00 GMT

给出一列数nums[i]以及一些query q[j]，输出ans[j]表示从nums[i]中可以最多选择几个数使得加和不超过q[j]。

仔细想想就发现虽然题目中说nums顺序不可交换，但因为可以随意取一些跳过一些，所以其实顺序并不影响，所以先对nums排序，然后预处理prefix sum，之后对于每个查询q[j]，二分prefix sum，看最多可以取多少个数，用python自带的二分函数依旧更快一些

用python自带函数

1 #2389
2 #Runtime: 86 ms (Beats 97.67%)
3 #Memory: 13.9 MB (Beats 29.7%)
4
5 class Solution(object):
6     def answerQueries(self, nums, queries):
7         """
8         :type nums: List[int]
9         :type queries: List[int]
10         :rtype: List[int]
11         """
12         nums.sort()
13         sums = [nums[0]]
14         for i in range(1, len(nums)):
15             sums.append(sums[-1] + nums[i])
16         ans = []
17         for q in queries:
18             ans.append(bisect_right(sums, q))
19         return ans

手写二分：

1 #2389
2 #Runtime: 93 ms (Beats 95.35%)
3 #Memory: 13.8 MB (Beats 56.98%)
4
5 class Solution(object):
6     def answerQueries(self, nums, queries):
7         """
8         :type nums: List[int]
9         :type queries: List[int]
10         :rtype: List[int]
11         """
12         nums.sort()
13         sums = [nums[0]]
14         for i in range(1, len(nums)):
15             sums.append(sums[-1] + nums[i])
16         ans = []
17         for q in queries:
18             l = 0
19             r = len(nums)
20             while l < r:
21                 mid = (l + r) // 2
22                 if sums[mid] > q:
23                     r = mid
24                 else:
25                     l = mid + 1
26             ans.append(l)
27         return ans

Uriel 2022-12-25 19:08 发表评论

[LeetCode]374. Guess Number Higher or Lower (Easy) Python-2022.11.16

Uriel — Wed, 16 Nov 2022 06:04:00 GMT

猜数字游戏，给定范围1-n，每次调用guess函数，按照返回值判断猜高了还是低了还是正确，输出选中的数字，简单二分

1 #374
2 #Runtime: 42 ms
3 #Memory Usage: 13.3 MB
4
5 # The guess API is already defined for you.
6 # @param num, your guess
7 # @return -1 if num is higher than the picked number
8 #          1 if num is lower than the picked number
9 #          otherwise return 0
10 # def guess(num):
11
12 class Solution(object):
13     def guessNumber(self, n):
14         """
15         :type n: int
16         :rtype: int
17         """
18         l = 1
19         r = n
20         while l < r:
21             mid = (l + r) // 2
22             if guess(mid) == 1:
23                 l = mid + 1
24             elif guess(mid) == 0:
25                 return mid
26             else:
27                 r = mid - 1
28         return l

Uriel 2022-11-16 14:04 发表评论

[LeetCode]222. Count Complete Tree Nodes (Medium) Python-2022.11.15

Uriel — Tue, 15 Nov 2022 10:58:00 GMT

给出一棵完全二叉树，求问一共多少个节点，题目要求复杂度小于O(n)，不过我用两种O(logn)*O(logn)的写法都没有直接O(n)暴搜来得快。。。

方法一：先DFS，不断走左子树的路径，算出二叉树层数max_depth，那么最后一层节点的数量为[1, 2^(max_depth-1)]，直接二分这个范围，然后算出最后一个叶子结点落在哪里，理论复杂度O(logn)*O(logn)

1 #222
2 #Runtime: 156 ms
3 #Memory Usage: 29.2 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def binarySearch(self, root, depth, mid, l, r):
13         if depth == self.max_depth - 1:
14             if root:
15                 return True
16             return False
17         if mid <= (l + r)//2:
18             return self.binarySearch(root.left, depth + 1, mid, l, (l + r)//2)
19         else:
20             return self.binarySearch(root.right, depth + 1, mid, (l + r)//2, r)
21
22     def countNodes(self, root):
23         """
24         :type root: TreeNode
25         :rtype: int
26         """
27         self.max_depth = 0
28         rt = root
29         while rt:
30             rt = rt.left
31             self.max_depth = self.max_depth + 1
32         if not self.max_depth:
33             return 0
34         l = 1
35         r = 2**(self.max_depth - 1)
36         while l < r:
37             mid = (l + r) // 2 + (l + r) % 2
38             if self.binarySearch(root, 0, mid, 1, 2**(self.max_depth - 1)):
39                 l = mid
40             else:
41                 r = mid - 1
42         return l + 2**(self.max_depth - 1) - 1

方法二：直接不断二分地递归找左右子树，直到遇到某个满二叉树节点，然后sum(左子树的搜索结果)+sum(右子树的搜索结果)+1（根结点），理论复杂度O(logn)*O(logn)

1 #222
2 #Runtime: 137 ms
3 #Memory Usage: 29.2 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def DFS(self, root, fg):
13         if not root:
14             return 1
15         if fg == 0:
16             return self.DFS(root.left, 0) + 1
17         return self.DFS(root.right, 1) + 1
18
19     def countNodes(self, root):
20         """
21         :type root: TreeNode
22         :rtype: int
23         """
24         if not root:
25             return 0
26         depth_l = self.DFS(root.left, 0)
27         depth_r = self.DFS(root.right, 1)
28         if depth_l == depth_r:
29             return 2**depth_l - 1
30         return self.countNodes(root.left) + self.countNodes(root.right) + 1

方法三：直接DFS整棵树求节点数量，复杂度O(n)，没想到这个方法反而最快...

1 #222
2 #Runtime: 87 ms
3 #Memory Usage: 29.4 MB
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def DFS(self, root):
13         if not root:
14             return
15         self.ans += 1
16         self.DFS(root.left)
17         self.DFS(root.right)
18
19     def countNodes(self, root):
20         """
21         :type root: TreeNode
22         :rtype: int
23         """
24         self.ans = 0
25         self.DFS(root)
26         return self.ans

Uriel 2022-11-15 18:58 发表评论