亚洲欧美区自拍先锋,欧美三区不卡,欧美日韩国产小视频

[LeetCode]739. Daily Temperatures (Medium) Python-2024.01.31

Uriel — Wed, 31 Jan 2024 10:05:00 GMT

早前的写法是倒序->http://www.shnenglu.com/Uriel/articles/229495.html
改了正序写法�Q�快了不��?br />

1 #739
2 #Runtime: 998 ms (Beats 89.58%)
3 #Memory: 23.6 MB (Beats 98.27%)
4
5 class Solution(object):
6     def dailyTemperatures(self, temperatures):
7         """
8         :type temperatures: List[int]
9         :rtype: List[int]
10         """
11         ans = [0] * len(temperatures)
12         stk = []
13         for i, t in enumerate(temperatures):
14             if not stk:
15                 stk.append(i)
16             else:
17                 while stk and temperatures[stk[-1]] < t:
18                     idx = stk.pop()
19                     ans[idx] = i - idx
20                 stk.append(i)
21         return ans

Uriel 2024-01-31 18:05 发表评论

[LeetCode]1457. Pseudo-Palindromic Paths in a Binary Tree (Medium) Python-2024.01.24

Uriel — Wed, 24 Jan 2024 11:26:00 GMT

思�\参�?>https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2573237/leetcode-the-hard-way-explained-line-by-line/?envType=daily-question&envId=2024-01-24

1 #1457
2 #Runtime: 911 ms (Beats 96.43%)
3 #Memory: 136.7 MB (Beats 10.71%)
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 pseudoPalindromicPaths (self, root, cnt = 0):
13         """
14         :type root: TreeNode
15         :rtype: int
16         """
17         if not root:
18             return 0
19         cnt ^= 1 << (root.val - 1)
20         if root.left is None and root.right is None:
21             return 1 if cnt & (cnt - 1) == 0 else 0
22         return self.pseudoPalindromicPaths(root.left, cnt) + self.pseudoPalindromicPaths(root.right, cnt)
23

Uriel 2024-01-24 19:26 发表评论

[LeetCode]606. Construct String from Binary Tree (Easy) Python-2023.12.08

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

先序遍历二叉树�ƈ且格式化输出�Q�DFS
注意如果只有叛_��树、左子树为空的话也要输出左子树的一�Ҏ��?br />

1 #606
2 #Runtime: 44 ms (Beats 7.3%)
3 #Memory: 16.2 MB (Beats 35.94%)
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 tree2str(self, root):
13         """
14         :type root: TreeNode
15         :rtype: str
16         """
17         self.ans = ""
18         def DFS(node):
19             self.ans += str(node.val)
20             if node.left or node.right:
21                 self.ans += '('
22                 if node.left:
23                     DFS(node.left)
24                 self.ans += ')'
25                 if node.right:
26                     self.ans += '('
27                     DFS(node.right)
28                     self.ans += ')'
29
30         if root:
31             DFS(root)
32         return self.ans

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

[LeetCode]1845. Seat Reservation Manager (Medium) Python-2023.11.06

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

模拟作�ؓ预订�pȝ��Q�有reserve和unreserve功能�Q�每�ơ自动分配无人的�~�号最��的座位

用python heapq做模�?br />

1 #1845
2 #Runtime: 1029 ms (Beats 20%)
3 #Memory: 44.4 MB (Beats 25.71%)
4
5 class SeatManager(object):
6
7     def __init__(self, n):
8         """
9         :type n: int
10         """
11         self.seats = []
12         self.n = n
13         for i in xrange(1, n + 1):
14             heapq.heappush(self.seats, i)
15
16
17     def reserve(self):
18         """
19         :rtype: int
20         """
21         if self.seats > 0:
22             seat = heapq.heappop(self.seats)
23             return seat
24         return -1
25
26
27     def unreserve(self, seatNumber):
28         """
29         :type seatNumber: int
30         :rtype: None
31         """
32         heapq.heappush(self.seats, seatNumber)
33
34
35
36
37 # Your SeatManager object will be instantiated and called as such:
38 # obj = SeatManager(n)
39 # param_1 = obj.reserve()
40 # obj.unreserve(seatNumber)

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

[LeetCode]515. Find Largest Value in Each Tree Row (Medium) Python-2023.10.24

Uriel — Tue, 24 Oct 2023 10:40:00 GMT

求二叉树每一层的最大��|��按层BFS

1 #515
2 #Runtime: 26 ms (Beats 68.6%)
3 #Memory: 17.7 MB (Beats 71.73%)
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 largestValues(self, root):
13         """
14         :type root: TreeNode
15         :rtype: List[int]
16         """
17         if not root:
18             return []
19         q = deque([root])
20         ans = []
21         while q:
22             sz = len(q)
23             t = float('-inf')
24             while sz:
25                 sz -= 1
26                 node = q.popleft()
27                 t = max(t, node.val)
28                 if node.left:
29                     q.append(node.left)
30                 if node.right:
31                     q.append(node.right)
32             ans.append(t)
33         return ans

Uriel 2023-10-24 18:40 发表评论

[LeetCode]844. Backspace String Compare (Easy) Python-2023.10.19

Uriel — Thu, 19 Oct 2023 20:09:00 GMT

判断两个字符串是否相�{�，字符串中间如果出�?�Q�则消除前一个字�?br />��单栈操作

1 #844
2 #Runtime: 18 ms (Beats 31.98%)
3 #Memory: 13.3 MB (Beats 27.21%)
4
5 class Solution(object):
6     def backspaceCompare(self, s, t):
7         """
8         :type s: str
9         :type t: str
10         :rtype: bool
11         """
12         stk1 = []
13         stk2 = []
14         for ch in s:
15             if ch == '#':
16                 if len(stk1):
17                     stk1.pop()
18             else:
19                 stk1.append(ch)
20         for ch in t:
21             if ch == '#':
22                 if len(stk2):
23                     stk2.pop()
24             else:
25                 stk2.append(ch)
26         return stk1 == stk2

Uriel 2023-10-20 04:09 发表评论

[LeetCode]1361. Validate Binary Tree Nodes (Medium) Python-2023.10.17

Uriel — Tue, 17 Oct 2023 14:00:00 GMT

�l�出一颗二叉树节点数量和每个节点的左儿子label集合以及叛_��子label集合�Q�问是否是一颗二叉树�Q�先用set选出root然后BFS�Q�如果同一个节点访问不止一�ơ或者有节点讉K��不到�Q�则不是二叉�?br />

1 #1361
2 #Runtime: 224 ms (Beats 92.11%)
3 #Memory: 15.5 MB (Beats 71.5%�Q?/span>
4
5 class Solution(object):
6     def validateBinaryTreeNodes(self, n, leftChild, rightChild):
7         """
8         :type n: int
9         :type leftChild: List[int]
10         :type rightChild: List[int]
11         :rtype: bool
12         """
13         rt = 0
14         child_nodes = set(leftChild + rightChild)
15         for i in xrange(n):
16             if i not in child_nodes:
17                 rt = i
18         vis = set()
19         q = deque([rt])
20         while q:
21             node = q.popleft()
22             if node in vis:
23                 return False
24             vis.add(node)
25             if leftChild[node] != -1:
26                 q.append(leftChild[node])
27             if rightChild[node] != -1:
28                 q.append(rightChild[node])
29         return len(vis) == n

Uriel 2023-10-17 22:00 发表评论

[LeetCode]287. Find the Duplicate Number (Medium) Python-2023.09.19

Uriel — Tue, 19 Sep 2023 10:00:00 GMT

扑և�一个数�l�中重复的数字（数组中的数字来自1-n�Q�只有一个数字重复出玎ͼ�可能出现两次以上��M��ơ数�Q?br />看Discussion get了��y妙思�\�Q�把nums[a]=b联想为a.next=b�Q�这��h��出重复出现的数字��q��当于��L��一个链表中的环

1 #287
2 #Runtime: 473 ms (Beats 70.43%)
3 #Memory: 25 MB (Beats 91.14%)
4
5 class Solution(object):
6     def findDuplicate(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         slow, fast, ans = 0, 0, 0
12         while True:
13             slow = nums[slow]
14             fast = nums[nums[fast]]
15             if slow == fast:
16                 while ans != slow:
17                     ans = nums[ans]
18                     slow = nums[slow]
19                 return ans

Uriel 2023-09-19 18:00 发表评论

[LeetCode]92. Reverse Linked List II (Medium) Python-2023.09.07

Uriel — Thu, 07 Sep 2023 08:04:00 GMT

��{单链表[left, right]区间的节�?br />

1 #92
2 #Runtime: 15 ms (Beats 63.77%)
3 #Memory: 13.7 MB (Beats 14.88%)
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 reverseBetween(self, head, left, right):
12         """
13         :type head: ListNode
14         :type left: int
15         :type right: int
16         :rtype: ListNode
17         """
18         ex_head = ListNode()
19         ex_head.next = head
20         pre = ex_head
21         for _ in range(left - 1):
22             pre = pre.next
23         cur = pre.next
24         tp = None
25         for _ in range(right - left + 1):
26             nxt = cur.next
27             cur.next = tp
28             tp = cur
29             cur = nxt
30         pre.next.next = cur
31         pre.next = tp
32         return ex_head.next

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

[LeetCode]725. Split Linked List in Parts (Medium) Python-2023.09.06

Uriel — Wed, 06 Sep 2023 13:51:00 GMT

把一个单链表均分分成k份，预先计算每䆾的节�Ҏ��量以及最后剩下多��节�?br />

1 #725
2 #Runtime: 15 ms (Beats 93.44%)
3 #Memory: 13.6 MB (Beats 73.77%)
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 splitListToParts(self, head, k):
12         """
13         :type head: ListNode
14         :type k: int
15         :rtype: List[ListNode]
16         """
17         n = 0
18         p = head
19         pre = None
20         while p:
21             n += 1
22             p = p.next
23         l, t = n//k, n%k
24         p = head
25         ans = []
26         for i in range(k):
27             ans.append(p)
28             for _ in range(l):
29                 if p:
30                     pre = p
31                     p = p.next
32             if t and p:
33                 pre = p
34                 p = p.next
35                 t -= 1
36             if pre:
37                 pre.next = None
38         return ans

Uriel 2023-09-06 21:51 发表评论

[LeetCode]138. Copy List with Random Pointer (Medium) Python-2023.09.05

Uriel — Tue, 05 Sep 2023 05:51:00 GMT

实现链表的深度copy�Q�链表除了next指针�Q�每个节点还有一个random指针�Q�指向�Q意节点，copy的时候也要还�?br />python的dict的妙�?br />

1 #138
2 #Runtime: 28 ms (Beats 92.87%)
3 #Memory: 13.9 MB (Beats 70.54%)
4
5 """
6 # Definition for a Node.
7 class Node:
8     def __init__(self, x, next=None, random=None):
9         self.val = int(x)
10         self.next = next
11         self.random = random
12 """
13
14 class Solution(object):
15     def copyRandomList(self, head):
16         """
17         :type head: Node
18         :rtype: Node
19         """
20         dic = {None:None}
21         cur = head
22         while cur:
23             dic[cur] = Node(cur.val)
24             cur = cur.next
25         cur = head
26         while cur:
27             cp = dic[cur]
28             cp.next = dic[cur.next]
29             cp.random = dic[cur.random]
30             cur = cur.next
31         return dic[head]

Uriel 2023-09-05 13:51 发表评论

[LeetCode]141. Linked List Cycle (Easy) C++/Python-2014.01.06/2023.09.04

Uriel — Mon, 04 Sep 2023 14:33:00 GMT

判断单链表是否有环，设一快一慢两个指针，快指针每�ơ前�q�两个节点，慢指针每�ơ前�q�一个节点，如果两个指针可以盔R��Q�则有环

python�?br />

1 #141
2 #Runtime: 57 ms (Beats 75.48%)
3 #Memory: 20.6 MB (Beats 48.63%)
4
5 # Definition for singly-linked list.
6 # class ListNode:
7 #     def __init__(self, x):
8 #         self.val = x
9 #         self.next = None
10
11 class Solution:
12     def hasCycle(self, head: Optional[ListNode]) -> bool:
13         slow, fast = head, head
14         while slow and fast and fast.next:
15             fast = fast.next.next
16             slow = slow.next
17             if slow == fast:
18                 return True
19         return False

C++�?br />

1 //141
2 //Runtime: 80 ms (Beats 6.2%)
3 //Memory: N/A (Beats N/A)
4
5 /**
6  * Definition for singly-linked list.
7  * struct ListNode {
8  *     int val;
9  *     ListNode *next;
10  *     ListNode(int x) : val(x), next(NULL) {}
11  * };
12  */
13 class Solution {
14 public:
15     bool hasCycle(ListNode *head) {
16         ListNode *slow = head, *fast = head;
17         while(fast && fast->next) {
18             slow = slow->next;
19             fast = fast->next->next;
20             if(slow == fast) break;
21         }
22         if(fast == NULL || fast->next == NULL) return false;
23         return true;
24     }
25 };

Uriel 2023-09-04 22:33 发表评论

[LeetCode]225. Implement Stack using Queues (Easy) Python-2023.08.28

Uriel — Mon, 28 Aug 2023 12:42:00 GMT

用队列模拟栈操作

1 #225
2 #Runtime: 7 ms (Beats 97.10%)
3 #Memory: 13.3 MB (Beats 55.58%)
4
5 class MyStack(object):
6
7     def __init__(self):
8         self.que = deque()
9
10     def push(self, x):
11         """
12         :type x: int
13         :rtype: None
14         """
15         self.que.append(x)
16
17     def pop(self):
18         """
19         :rtype: int
20         """
21         for _ in range(len(self.que) - 1):
22             self.que.append(self.que.popleft())
23         return self.que.popleft()
24
25
26     def top(self):
27         """
28         :rtype: int
29         """
30         return self.que[-1]
31
32
33     def empty(self):
34         """
35         :rtype: bool
36         """
37         return len(self.que) == 0
38
39
40
41 # Your MyStack object will be instantiated and called as such:
42 # obj = MyStack()
43 # obj.push(x)
44 # param_2 = obj.pop()
45 # param_3 = obj.top()
46 # param_4 = obj.empty()

Uriel 2023-08-28 20:42 发表评论

[LeetCode]239. Sliding Window Maximum (Hard) Python-2023.08.16

Uriel — Wed, 16 Aug 2023 08:53:00 GMT

�l�出一列数nums�Q�求�q�列��C��左到右长度k的滑动窗口内的最大��g��ơ是多少�Q�维护一个优先队列，当计��到�W�i个数�Ӟ��优先队列里面保存所有长度k以内值大于nums[i]的数的下标（因此可以保证nums[0]是窗口长度k以内的最大��|��

1 #239
2 #Runtime: 1773 ms (Beats 16%)
3 #Memory: 30.5 MB (Beats 48.38%)
4
5 class Solution(object):
6     def maxSlidingWindow(self, nums, k):
7         """
8         :type nums: List[int]
9         :type k: int
10         :rtype: List[int]
11         """
12         wd_max = []
13         ans = []
14         for i in range(len(nums)):
15             if wd_max and wd_max[0] == i - k:
16                 wd_max.pop(0)
17             while wd_max and nums[wd_max[-1]] < nums[i]:
18                 wd_max.pop()
19             wd_max.append(i)
20             if i >= k - 1:
21                 ans.append(nums[wd_max[0]])
22         return ans

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

[LeetCode]215. Kth Largest Element in an Array (Medium) Python-2023.08.14

Uriel — Mon, 14 Aug 2023 09:02:00 GMT

求一列数�W�k大的敎ͼ�heap应用

1 #215
2 #Runtime: 822 ms (Beats 46.88%)
3 #Memory: 23.3 MB (Beats 81.50%)
4
5 class Solution(object):
6     def findKthLargest(self, nums, k):
7         """
8         :type nums: List[int]
9         :type k: int
10         :rtype: int
11         """
12         hp = []
13         for n in nums:
14             heapq.heappush(hp, n)
15             if len(hp) > k:
16                 heapq.heappop(hp)
17         return hp[0]

Uriel 2023-08-14 17:02 发表评论

[LeetCode]95. Unique Binary Search Trees II (Medium) C++/Python-2014.01.11/2023.08.05

Uriel — Sat, 05 Aug 2023 16:44:00 GMT

输出1-n数字�l�成的所有二叉搜索树�Q�递归+dp�Q�用python3的话�q�可以加lru_cache

C++

1 //95
2 //Runtime: 128 ms (Beats 7.1%)
3
4 /**
5  * Definition for binary tree
6  * struct TreeNode {
7  *     int val;
8  *     TreeNode *left;
9  *     TreeNode *right;
10  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
11  * };
12  */
13 class Solution {
14 public:
15     vector sov(int l, int r) {
16         vector ans;
17         if(l > r) ans.push_back(NULL);
18         else {
19             for(int i = l; i <= r; ++i) {
20                 vector left = sov(l, i - 1);
21                 vector right = sov(i + 1, r);
22                 for(int ll = 0; ll < left.size(); ++ll) {
23                     for(int rr = 0; rr < right.size(); ++rr) {
24                         TreeNode *root = new TreeNode(i);
25                         root->left = left[ll];
26                         root->right = right[rr];
27                         ans.push_back(root);
28                     }
29                 }
30             }
31         }
32         return ans;
33     }
34
35     vector generateTrees(int n) {
36         return sov(1, n);
37     }
38 };

Python

1 #95
2 #Runtime: 38 ms (Beats 79.12%)
3 #Memory: 16.2 MB (Beats 63.19%)
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 generateTrees(self, n):
13         """
14         :type n: int
15         :rtype: List[TreeNode]
16         """
17
18         def dp(l, r):
19             if l > r:
20                 return [None]
21             ans = []
22             for i in range(l, r + 1):
23                 l_tree = dp(l, i - 1)
24                 r_tree = dp(i + 1, r)
25                 for ll in l_tree:
26                     for rr in r_tree:
27                         root = TreeNode(i)
28                         root.left = ll
29                         root.right = rr
30                         ans.append(root)
31             return ans
32         return dp(1, n)

Uriel 2023-08-06 00:44 发表评论

[LeetCode]735. Asteroid Collision (Medium) Python-2023.07.20

Uriel — Thu, 20 Jul 2023 08:01:00 GMT

�l�出一列数�Q�负��C��表向左移动，正数代表向右�U�d��Q�如果连着的两个数分别向右和向左，则会��撞�Q�只剩下�l�对值更大的那一个数�Q�问所有碰撞结束之后剩下的list
基本栈操�?br />

1 #735
2 #Runtime: 98 ms (Beats 14.98%)
3 #Memory: 14.6 MB (Beats 16.21%)
4
5 class Solution(object):
6     def asteroidCollision(self, asteroids):
7         """
8         :type asteroids: List[int]
9         :rtype: List[int]
10         """
11         stk = [asteroids[0]]
12         for x in asteroids[1:]:
13             stk.append(x)
14             while len(stk) > 1 and stk[-2] > 0 and stk[-1] < 0:
15                 pre1 = stk[-1]
16                 pre2 = stk[-2]
17                 stk.pop()
18                 stk.pop()
19                 if abs(pre1) != abs(pre2):
20                     stk.append(pre1) if abs(pre1) > abs(pre2) else stk.append(pre2)
21         return stk

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

[LeetCode]445. Add Two Numbers II (Medium) Python-2023.07.17

Uriel — Mon, 17 Jul 2023 07:55:00 GMT

链表形式存储的大数加法，参考了Discussion的简�z�写�?br />

1 #445
2 #Runtime: 56 ms (Beats 64.47%)
3 #Memory: 13.6 MB (Beats 13.21%)
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 addTwoNumbers(self, l1, l2):
12         """
13         :type l1: ListNode
14         :type l2: ListNode
15         :rtype: ListNode
16         """
17         n1, n2 = [], []
18         while l1:
19             n1.append(l1.val)
20             l1 = l1.next
21         while l2:
22             n2.append(l2.val)
23             l2 = l2.next
24         t = 0
25         ans = None
26         while n1 or n2 or t:
27             v1 = n1.pop() if n1 else 0
28             v2 = n2.pop() if n2 else 0
29             t, v = divmod(v1 + v2 + t, 10)
30             node = ListNode(v)
31             node.next = ans
32             ans = node
33         return ans or ListNode(0)

Uriel 2023-07-17 15:55 发表评论

[LeetCode]863. All Nodes Distance K in Binary Tree (Medium) Python-2023.07.11

Uriel — Tue, 11 Jul 2023 09:09:00 GMT

求二叉树中和某个target节点距离为k的所有节点��|��先BFS建图�Q�python的dict存图�Q�，然后在图上BFS求解

1 #863
2 #Runtime: 25 ms (Beats 49.62%)
3 #Memory: 13.6 MB (Beats 74.5%)
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, x):
8 #         self.val = x
9 #         self.left = None
10 #         self.right = None
11
12 class Solution(object):
13     def distanceK(self, root, target, k):
14         """
15         :type root: TreeNode
16         :type target: TreeNode
17         :type k: int
18         :rtype: List[int]
19         """
20         graph = {}
21         dep_target = 0
22         q = deque([[root, -1]])
23         while q:
24             node, f = q.popleft()
25             if node.val not in graph:
26                 if f != -1:
27                     graph[node.val] = [f]
28                     graph[f].append(node.val)
29                 else:
30                     graph[node.val] = []
31             else:
32                 graph[node.val].append(f)
33                 graph[f].append(node.val)
34             if node.left:
35                 q.append([node.left, node.val])
36             if node.right:
37                 q.append([node.right, node.val])
38         q = deque([target.val])
39         dis = 0
40         ans = []
41         vis = set([target.val])
42         while q and dis < k:
43             sz = len(q)
44             while sz:
45                 sz -= 1
46                 node = q.popleft()
47                 for i in graph[node]:
48                     if i not in vis:
49                         q.append(i)
50                         vis.add(i)
51             dis += 1
52         if dis == k:
53             ans = list(q)
54         return ans

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

[LeetCode]373. Find K Pairs with Smallest Sums (Medium) Python-2023.06.27

Uriel — Tue, 27 Jun 2023 14:38:00 GMT

从两个升序排列的数组分别抽出一个数�l�成pair�Q�输出和最��的k个pair�Q�优先队列应�?br />

1 #373
2 #Runtime: 1051 ms (Beats 45.18%)
3 #Memory: 29.9 MB (Beats 87.95%)
4
5 class Solution(object):
6     def kSmallestPairs(self, nums1, nums2, k):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :type k: int
11         :rtype: List[List[int]]
12         """
13         fg = set()
14         ans = []
15         hp = []
16         for i in range(min(len(nums1), k)):
17             heapq.heappush(hp, (nums1[i] + nums2[0], nums1[i], nums2[0], 0))
18         while k and hp:
19             _, i, j, idx = heapq.heappop(hp)
20             ans.append([i, j])
21             if idx < len(nums2) - 1:
22                 heapq.heappush(hp, (i + nums2[idx + 1], i, nums2[idx + 1], idx + 1))
23             k -= 1
24         return ans

Uriel 2023-06-27 22:38 发表评论

[LeetCode]2462. Total Cost to Hire K Workers (Medium) Python-2023.06.26

Uriel — Mon, 26 Jun 2023 16:23:00 GMT

�l�定一个数列costs�Q�一共k�ơ操作，每次从前candidates和后candidates个数里面选较��的一个，问k�ơ取到的k个数只和
�l�护两个优先队列�Q�一个存前candidates�Q�一个存后candidates�Q�注意每�ơpop之后要push后一�?前一个数

1 #2462
2 #Runtime: 1356 ms (Beats 44.93%)
3 #Memory: 21.8 MB (Beats 68.12%)
4
5 class Solution(object):
6     def totalCost(self, costs, k, candidates):
7         """
8         :type costs: List[int]
9         :type k: int
10         :type candidates: int
11         :rtype: int
12         """
13         left = costs[:candidates]
14         right = costs[max(candidates, len(costs) - candidates):]
15         heapify(left)
16         heapify(right)
17         ans = 0
18         i = candidates
19         j = len(costs) - candidates - 1
20         for _ in range(k):
21             if (not right) or (left and left[0] <= right[0]):
22                 ans += heappop(left)
23                 if i <= j:
24                     heappush(left, costs[i])
25                     i += 1
26             else:
27                 ans += heappop(right)
28                 if i <= j:
29                     heappush(right, costs[j])
30                     j -= 1
31         return ans

Uriel 2023-06-27 00:23 发表评论

[LeetCode]1569. Number of Ways to Reorder Array to Get Same BST (Hard) Python3-2023.06.16

Uriel — Fri, 16 Jun 2023 09:23:00 GMT

�l�定一列不重复的数�Q�依�ơ插入一��늩�树构成二叉搜索树�Q�问若打��p��一列数的顺序，一共有多少�U�不同的打�ؕ方式�Q�可以得��C��L��BST�Q�递归分治思想
假设当前数列长l�Q�那么第一个数字决定了root的位�|�，无法�U�d��Q�之后的数字比root大的数和比root��的数的数量是一定的�Q�假设有m个数比root大，n个数比root��（m+n+1=l�Q�。那么打乱顺序还可以构成一��L��BST的数量就是组合数C(m, m+n)。而左子树和右子树又将�q�行同样的计��。注意最�l�结果要-1�Q�减��d��本的那种排列方式�Q?br />

1 #1569
2 #Runtime: 173 ms (Beats 71.74%)
3 #Memory: 21.8 MB (Beats 51.9%)
4
5 class Solution:
6     def numOfWays(self, nums: List[int]) -> int:
7         MOD = 10 ** 9 + 7
8
9         def cal(seq):
10             if not seq:
11                 return 1
12             root = seq[0]
13             l_tree = [num for num in seq if num < root]
14             r_tree = [num for num in seq if num > root]
15             return math.comb(len(l_tree) + len(r_tree), len(l_tree)) * cal(l_tree) * cal(r_tree) % MOD
16         return (cal(nums) - 1) % MOD

Uriel 2023-06-16 17:23 发表评论

[LeetCode]530. Minimum Absolute Difference in BST (Easy) Python-2023.06.14

Uriel — Wed, 14 Jun 2023 06:57:00 GMT

求二叉搜索树中元素��g��差最��是多少�Q�DFS中序遍历的同时记录当前节点和上一�ơ访问的节点��g��差即�?br />

1 #530
2 #Runtime: 44 ms (Beats 43.16%)
3 #Memory: 17.3 MB (Beats 71.85%)
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 getMinimumDifference(self, root):
13         """
14         :type root: TreeNode
15         :rtype: int
16         """
17         self.ans = 100000
18         self.pre_val = None
19
20         def DFS(node):
21             if not node:
22                 return
23             DFS(node.left)
24             if self.pre_val is not None:
25                 self.ans = min(self.ans, node.val - self.pre_val)
26             self.pre_val = node.val
27             DFS(node.right)
28
29         DFS(root)
30         return self.ans

Uriel 2023-06-14 14:57 发表评论

[LeetCode]2542. Maximum Subsequence Score (Medium) Python-2023.05.24

Uriel — Wed, 24 May 2023 13:32:00 GMT

�l�出同样长度的两列数nums1�Q�num2�Q�求其中长度为k的子�Ԍ��使得max(sum(a_i)*min(b_i))�Q�a_i, b_i∈长度k的子�Ԍ��输出max�l�果�Q�优先队列基本应�?br />

1 #2542
2 #Runtime: 1378 ms (Beats 42.86%)
3 #Memory: 42.3 MB (Beats 33.33%)
4
5 class Solution(object):
6     def maxScore(self, nums1, nums2, k):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :type k: int
11         :rtype: int
12         """
13         hp = []
14         ans, t_sum = 0, 0
15         for a, b in sorted(list(zip(nums1, nums2)), key=itemgetter(1), reverse=True):
16             t_sum += a
17             heappush(hp, a)
18             if len(hp) == k:
19                 ans = max(ans, t_sum * b)
20                 t_sum -= heappop(hp)
21         return ans

Uriel 2023-05-24 21:32 发表评论

[LeetCode]703. Kth Largest Element in a Stream (Easy) Python-2023.05.23

Uriel — Tue, 23 May 2023 11:37:00 GMT

求一列数的第K大，优先队列打卡�?br />

1 #703
2 #Runtime: 95 ms (Beats 80.5%)
3 #Memory: 17.9 MB (Beats 17.87%)
4
5 class KthLargest(object):
6
7     def __init__(self, k, nums):
8         """
9         :type k: int
10         :type nums: List[int]
11         """
12         self.nums = nums
13         self.K = k
14         heapify(self.nums)
15         while len(self.nums) > self.K:
16             heappop(self.nums)
17
18     def add(self, val):
19         """
20         :type val: int
21         :rtype: int
22         """
23         if len(self.nums) < self.K:
24             heappush(self.nums, val)
25         elif val > self.nums[0]:
26             heapreplace(self.nums, val)
27         return self.nums[0]
28
29
30
31 # Your KthLargest object will be instantiated and called as such:
32 # obj = KthLargest(k, nums)
33 # param_1 = obj.add(val)

Uriel 2023-05-23 19:37 发表评论

[LeetCode]2130. Maximum Twin Sum of a Linked List (Medium) Python-2023.05.17

Uriel — Wed, 17 May 2023 10:56:00 GMT

�l�计单链表前后对应位�|�的和，输出最大的�?br />先用快慢两个指针�Q�快指针每次前进两个node�Q�这样定位到单链表中心位�|�，然后��{后一半链表的指针�Q�很巧妙�Q�思�\参考Discussion�Q?br />

1 #2130
2 #Runtime: 1108 ms (Beats 78.1%)
3 #Memory: 72.2 MB (Beats 80.63%)
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 pairSum(self, head):
12         """
13         :type head: Optional[ListNode]
14         :rtype: int
15         """
16         node_slow, node_fast = head, head
17         ans = 0
18         while node_fast and node_fast.next:
19             node_fast = node_fast.next.next
20             node_slow = node_slow.next
21         node_cur, node_pre = node_slow, None
22         while node_cur:
23             node_cur.next, node_pre, node_cur = node_pre, node_cur, node_cur.next
24         while node_pre:
25             ans = max(ans, head.val + node_pre.val)
26             node_pre = node_pre.next
27             head = head.next
28         return ans

Uriel 2023-05-17 18:56 发表评论

[LeetCode]24. Swap Nodes in Pairs (Medium) Python-2023.05.16

Uriel — Tue, 16 May 2023 12:12:00 GMT

成对交换单链表的元素�Q�必��通过修改指针实现�Q�参考了Discussion关于self的��?br />

1 #24
2 #Runtime: 23 ms (Beats 24.1%)
3 #Memory: 13.4 MB (Beats 79.10%)
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 swapPairs(self, head):
12         """
13         :type head: ListNode
14         :rtype: ListNode
15         """
16         pre = self
17         pre.next = head
18         while pre.next and pre.next.next:
19             t = pre.next
20             t_next = t.next
21             pre.next, t_next.next, t.next = t_next, t, t_next.next
22             pre = t
23         return self.next

Uriel 2023-05-16 20:12 发表评论

[LeetCode]1721. Swapping Nodes in a Linked List (Medium) Python-2023.05.15

Uriel — Mon, 15 May 2023 10:03:00 GMT

交换单链表位�|�k和n-k的两个元素，链表元素个数事先未知�Q�只交换两个元素的值即可，不用调整链表指针�Q?br />

1 #1721
2 #Runtime: 1265 ms (Beats 56.45%)
3 #Memory: 91.1 MB (Beats 69.35%)
4
5 class Solution(object):
6     def swapNodes(self, head, k):
7         """
8         :type head: ListNode
9         :type k: int
10         :rtype: ListNode
11         """
12         t = 1
13         head2, head3 = head, head
14         while t < k:
15             head2 = head2.next
16             head3 = head3.next
17             t += 1
18         n = t
19         while head3:
20             head3 = head3.next
21             n += 1
22         t = 0
23         head3 = head
24         while t < n - k - 1:
25             head3 = head3.next
26             t += 1
27         head2.val, head3.val = head3.val, head2.val
28         return head

Uriel 2023-05-15 18:03 发表评论

[LeetCode]1046. Last Stone Weight (Easy) Python-2023.04.24

Uriel — Mon, 24 Apr 2023 12:22:00 GMT

有一堆石子，每次取其中最大重量的两颗�Q�若重量一��P��则两颗都消失�Q�否则其中一颗消失，另一颗重量变��Z��者重量之差，问最后剩下的矛_��重量多少�Q�用priority queue直接模拟卛_��

1 #1046
2 #Runtime: 29 ms (Beats 83.46%)
3 #Memory: 13.9 MB (Beats 47.65%)
4
5 class Solution:
6     def lastStoneWeight(self, stones: List[int]) -> int:
7         hp = []
8         for st in stones:
9             heapq.heappush(hp, -st)
10         while len(hp) >= 2:
11             s1 = heapq.heappop(hp)
12             s2 = heapq.heappop(hp)
13             if s2 > s1:
14                 heapq.heappush(hp, s1 - s2)
15         return abs(hp[0]) if hp else 0

Uriel 2023-04-24 20:22 发表评论

[LeetCode]662. Maximum Width of Binary Tree (Medium) Python-2023.04.20

Uriel — Thu, 20 Apr 2023 10:45:00 GMT

判断二叉树所有层中同一层左双��点宽度最大是多少�Q�BFS�Q�每�ơ处理一层�ƈ且求宽度�Q�多开了一个deque来存每个�q�队的节点的�~�号�Q�可以把�~�号和node节点信息合�ƈ�Q�用一个新的node class保存�Q�但��g��用两个deque更省内存

1 #662
2 #Runtime: 28 ms (Beats 72.48%)
3 #Memory: 14.9 MB (Beats 82.57%)
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 widthOfBinaryTree(self, root):
13         """
14         :type root: TreeNode
15         :rtype: int
16         """
17         q = deque([root])
18         q_idx = deque([1])
19         ans = 0
20         while q:
21             s = len(q)
22             for i in range(s):
23                 node = q.popleft()
24                 x = q_idx.popleft()
25                 if i == 0:
26                     tp_min = x
27                 if i == s - 1:
28                     tp_max = x
29                 if node.left:
30                     q.append(node.left)
31                     q_idx.append(2 * x - 1)
32                 if node.right:
33                     q.append(node.right)
34                     q_idx.append(2 * x)
35             ans = max(ans, tp_max - tp_min + 1)
36         return ans

Uriel 2023-04-20 18:45 发表评论