久久国产乱子伦免费精品,国产精品久久久久蜜芽,99久久精品国产一区二区蜜芽

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

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

�l�出每个��q��开花时��_��L��l�点�Q�，输出people数组每个人到达时有多��花在开。线�D�|��、扫描线、二�?br />

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

�l�出一个先单调上升后单调下降的数组�Q�查询某个数�Q�若不存在输�?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

�l�出一列一排序的数�l�，问某个数target在里面第一�ơ和最后一�ơ出现的位置�Q�二分，用python的bisect很方�?br />

#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

�l�出二维0-1矩阵�Q�每行都��p��l�的1之后�?�Q�输出含1最��的k行，二分��定每行0-1分隔的位�|�，heapq存每行的1的数�?br />

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

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

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

一个递增的数�l�从中间切断�Q�前面一半append到数�l�后面，问某个数target在不在数�l�内�Q�二分，每次判断mid实在左边的那一�D�递增数组�q�是双��一�D?br />

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

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

�Ҏ��一�Q�当成一�?D递增向量�Q�二分，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

�Ҏ��二：先确定在哪一行，再扫描该行所有列�Q�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]旉��Q�问要同时运行n台机器，每台机器需要一个电池，最多可以运行多久，二分

一开始r取小了点�Q�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

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

#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

二分法求先单调增然后单调减的数列的最大��g��?br />

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�ơ方计算�Q�二�?br />

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�Q�每个event有开始和�l�束旉��以及value�Q�最多参加k个event问最多获得多��value�Q�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

�l�定一个数列，问其中最��多��个�q�箋元素之和可以大于target�Q�预处理前缀和，然后二分�{�案判断是否可行�Q�复杂度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列的二维矩阵�Q�初始所有元素�ؓ0�Q�代表均可以赎ͼ�每天有一个格子变�?�Q�不可走�Q�问最�q�第几天可以依旧从第一行走到最后一行（具体从第几列开始，走向�W�几列无要求�Q�，可以四个方向�?br />二分�{�案+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

�l�出一列数以及每个位置�?�?需要的cost�Q�问最��多��cost可以让整列数变成一��L��。因为最后相同的数必定在原数列最��值和最大��g��_��而且总cost会是个U型曲�U�，所以二分结果找最��?br />参考了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

�l�出两个数列arr1和arr2�Q�可以进行操作将arr1[i]换�ؓarr2[j]�Q�求问最��操作几�ơ可以让arr1变�ؓ严格递增数列�Q�如果不存在输出-1�Q�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�q�且可以查询�W�i�ơsnapshot时数�l�某个index的数��|��数组中的所有数值都支持无限�ơset�Q��ƈ且由于memory限制�Q�不能直接存储每一�ơsnapshot的数�l�所有元�?br />参考了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

�l�出一个字�W�组成的已从��到大排序的list和一个target字符�Q�问list中第一个比target大的字符是什么，若不存在�Q�输出list�W�一个字�W�，二分的简单应�?br />

手写二分�Q?br />

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自带二分函数�Q?br />

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

一个二�l�矩阵，从左到右�Q��M��C��数字不增�Q�求矩阵中负数有多少�Q�水�?br />
思�\一�Q�设个游标，记录当前行非负数有几�?br />

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

思�\二：每行二分求位�|�（复杂度更低，但这题数据估计很��_��所以反而慢�Q?br />

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

�l�出一串数�Q�对于每一位，输出从第一个数到当前数的最长不降子序列长度�Q��y妙利用stack�Q�参考了discussion
�l�护一个单调不降的stk�Q�对于每一位的数字�Q�二分stk�Q�若该数字比所有stk里的数都大，则append到末��，否则替换stk里位于该数右边的一个数�Q�因��求单调不降而不是单调增�Q�，二分直接用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

�l�出一个数列spells和一个数列potions�Q�用spells里面每个��C��ơ乘以potions里面每个敎ͼ�输出和spells�{�长的数列，每个值等于用spells里面每个��C��以potions每个数得到的length(potions)个数里面大于�{�于�l�定值success的数�?br />先对potions按从��到大排序，然后对于spells里面每个敎ͼ�二分�W�一个符合大于等于success的数的位�|?br />注意边界�?br />

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

实现二分查找�Q�大水题

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使得�q�堆香蕉能在h旉��内吃完，��单而分�Q�注意下限�?

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

�l�出每个公交车完成一�ơtrip所需旉��time[i]�Q�以及所有需要完成的trip数totalTrips�Q�问最��多久能完成所有trips�Q�同一时刻可以�z�և��L��辆�R
直接二分�l�果

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

�l�出所有货物的重量weights�Q�以及需要在days天内�q�输完，求运载量最��需要多��，�q�输货物需要按weights��序�q�行

因�ؓ货物的传输是��定��序的所以比较简单，二分�{�案�Q�每�ơ判断是否能在days天内�q�输完即可，二分的下限是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

一列已�l�排序的list�Q�其中除了一个数只出��C��ơ，别的数都出现恰好两次�Q�求如何用O(1)�I�间复杂度和O(logn)旉��复杂度内扑և��q�个敎ͼ�看这个复杂度��q��是二分，具体思�\有参考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

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

Python bisect库函数版�Q?br />

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)

手写二分�Q?br />

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

�l�出一列数nums[i]以及一些query q[j]�Q�输出ans[j]表示从nums[i]中可以最多选择几个��C��得加和不��过q[j]�?/div>

仔细��x��发现虽焉��目中说nums��序不可交换�Q�但因�ؓ可以随意取一些蟩�q�一些，所以其实顺序�ƈ不媄响，所以先对nums排序�Q�然后预处理prefix sum�Q�之后对于每个查询q[j]�Q�二分prefix sum�Q�看最多可以取多少个数�Q�用python自带的二分函��C��旧更快一�?br />
用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

手写二分�Q?br />

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

猜数字游戏，�l�定范围1-n�Q�每�ơ调用guess函数�Q�按照返回值判断猜高了�q�是低了�q�是正确�Q�输出选中的数字，��单二�?br />

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

�l�出一��完全二叉树�Q�求问一共多��个节点�Q�题目要求复杂度��于O(n)�Q�不�q�我用两�U�O(logn)*O(logn)的写法都没有直接O(n)暴搜来得快。。�?br />
�Ҏ��一�Q�先DFS�Q�不断走左子树的路径�Q�算��Z��叉树层数max_depth�Q�那么最后一层节点的数量为[1, 2^(max_depth-1)]�Q�直接二分这个范��_��然后��出最后一个叶子结点落在哪里，理论复杂度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

�Ҏ��二：直接不断二分地递归扑ַ�叛_��树，直到遇到某个满二叉树节点�Q�然后sum(左子树的搜烦�l�果)+sum(叛_��树的搜烦�l�果)+1�Q�根�l�点�Q�，理论复杂度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整棵树求节点数量�Q�复杂度O(n)�Q�没惛_��q�个�Ҏ��反而最�?..

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