feat: update solutions to lc problems (#2178)

* No.2487.Remove Nodes From Linked List
* No.2806.Account Balance After Rounded Purchase
* No.2807.Insert Greatest Common Divisors in Linked List
* No.2808.Minimum Seconds to Equalize a Circular Array
* No.2809.Minimum Time to Make Array Sum At Most x
* No.2810.Faulty Keyboard
* No.2811.Check if it is Possible to Split Array
* No.2985.Calculate Compressed Mean
* No.2987.Find Expensive Cities
* No.2988.Manager of the Largest Department

Author: yanglbme

solution/2400-2499/2487.Remove Nodes From Linked List/README.md

@@ -101,16 +101,13 @@ class Solution:
 #         self.next = next
 class Solution:
     def removeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        dummy = ListNode(next=head)
+        dummy = ListNode(inf, head)
         cur = head
-        stk = []
+        stk = [dummy]
         while cur:
-            while stk and stk[-1].val < cur.val:
+            while stk[-1].val < cur.val:
                 stk.pop()
-            if stk:
-                stk[-1].next = cur
-            else:
-                dummy.next = cur
+            stk[-1].next = cur
             stk.append(cur)
             cur = cur.next
         return dummy.next
@@ -169,17 +166,14 @@ class Solution {
  */
 class Solution {
     public ListNode removeNodes(ListNode head) {
-        ListNode dummy = new ListNode(0, head);
+        ListNode dummy = new ListNode(1 << 30, head);
         Deque<ListNode> stk = new ArrayDeque<>();
+        stk.offerLast(dummy);
         for (ListNode cur = head; cur != null; cur = cur.next) {
-            while (!stk.isEmpty() && stk.peekLast().val < cur.val) {
+            while (stk.peekLast().val < cur.val) {
                 stk.pollLast();
             }
-            if (!stk.isEmpty()) {
-                stk.peekLast().next = cur;
-            } else {
-                dummy.next = cur;
-            }
+            stk.peekLast().next = cur;
             stk.offerLast(cur);
         }
         return dummy.next;
@@ -240,18 +234,14 @@ public:
 class Solution {
 public:
     ListNode* removeNodes(ListNode* head) {
-        ListNode* dummy = new ListNode(0, head);
+        ListNode* dummy = new ListNode(1e9, head);
         ListNode* cur = head;
-        vector<ListNode*> stk;
+        vector<ListNode*> stk = {dummy};
         for (ListNode* cur = head; cur; cur = cur->next) {
-            while (stk.size() && stk.back()->val < cur->val) {
+            while (stk.back()->val < cur->val) {
                 stk.pop_back();
             }
-            if (stk.size()) {
-                stk.back()->next = cur;
-            } else {
-                dummy->next = cur;
-            }
+            stk.back()->next = cur;
             stk.push_back(cur);
         }
         return dummy->next;
@@ -301,17 +291,13 @@ func removeNodes(head *ListNode) *ListNode {
  * }
  */
 func removeNodes(head *ListNode) *ListNode {
-	dummy := &ListNode{Next: head}
-	stk := []*ListNode{}
+	dummy := &ListNode{1 << 30, head}
+	stk := []*ListNode{dummy}
 	for cur := head; cur != nil; cur = cur.Next {
-		for len(stk) > 0 && stk[len(stk)-1].Val < cur.Val {
+		for stk[len(stk)-1].Val < cur.Val {
 			stk = stk[:len(stk)-1]
 		}
-		if len(stk) > 0 {
-			stk[len(stk)-1].Next = cur
-		} else {
-			dummy.Next = cur
-		}
+		stk[len(stk)-1].Next = cur
 		stk = append(stk, cur)
 	}
 	return dummy.Next
@@ -369,17 +355,13 @@ function removeNodes(head: ListNode | null): ListNode | null {
  */
 
 function removeNodes(head: ListNode | null): ListNode | null {
-    const dummy = new ListNode(0, head);
-    const stk: ListNode[] = [];
+    const dummy = new ListNode(Infinity, head);
+    const stk: ListNode[] = [dummy];
     for (let cur = head; cur; cur = cur.next) {
-        while (stk.length && stk.at(-1)!.val < cur.val) {
+        while (stk.at(-1)!.val < cur.val) {
             stk.pop();
         }
-        if (stk.length) {
-            stk.at(-1)!.next = cur;
-        } else {
-            dummy.next = cur;
-        }
+        stk.at(-1)!.next = cur;
         stk.push(cur);
     }
     return dummy.next;

solution/2400-2499/2487.Remove Nodes From Linked List/README_EN.md

@@ -91,16 +91,13 @@ class Solution:
 #         self.next = next
 class Solution:
     def removeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        dummy = ListNode(next=head)
+        dummy = ListNode(inf, head)
         cur = head
-        stk = []
+        stk = [dummy]
         while cur:
-            while stk and stk[-1].val < cur.val:
+            while stk[-1].val < cur.val:
                 stk.pop()
-            if stk:
-                stk[-1].next = cur
-            else:
-                dummy.next = cur
+            stk[-1].next = cur
             stk.append(cur)
             cur = cur.next
         return dummy.next
@@ -157,17 +154,14 @@ class Solution {
  */
 class Solution {
     public ListNode removeNodes(ListNode head) {
-        ListNode dummy = new ListNode(0, head);
+        ListNode dummy = new ListNode(1 << 30, head);
         Deque<ListNode> stk = new ArrayDeque<>();
+        stk.offerLast(dummy);
         for (ListNode cur = head; cur != null; cur = cur.next) {
-            while (!stk.isEmpty() && stk.peekLast().val < cur.val) {
+            while (stk.peekLast().val < cur.val) {
                 stk.pollLast();
             }
-            if (!stk.isEmpty()) {
-                stk.peekLast().next = cur;
-            } else {
-                dummy.next = cur;
-            }
+            stk.peekLast().next = cur;
             stk.offerLast(cur);
         }
         return dummy.next;
@@ -228,18 +222,14 @@ public:
 class Solution {
 public:
     ListNode* removeNodes(ListNode* head) {
-        ListNode* dummy = new ListNode(0, head);
+        ListNode* dummy = new ListNode(1e9, head);
         ListNode* cur = head;
-        vector<ListNode*> stk;
+        vector<ListNode*> stk = {dummy};
         for (ListNode* cur = head; cur; cur = cur->next) {
-            while (stk.size() && stk.back()->val < cur->val) {
+            while (stk.back()->val < cur->val) {
                 stk.pop_back();
             }
-            if (stk.size()) {
-                stk.back()->next = cur;
-            } else {
-                dummy->next = cur;
-            }
+            stk.back()->next = cur;
             stk.push_back(cur);
         }
         return dummy->next;
@@ -289,17 +279,13 @@ func removeNodes(head *ListNode) *ListNode {
  * }
  */
 func removeNodes(head *ListNode) *ListNode {
-	dummy := &ListNode{Next: head}
-	stk := []*ListNode{}
+	dummy := &ListNode{1 << 30, head}
+	stk := []*ListNode{dummy}
 	for cur := head; cur != nil; cur = cur.Next {
-		for len(stk) > 0 && stk[len(stk)-1].Val < cur.Val {
+		for stk[len(stk)-1].Val < cur.Val {
 			stk = stk[:len(stk)-1]
 		}
-		if len(stk) > 0 {
-			stk[len(stk)-1].Next = cur
-		} else {
-			dummy.Next = cur
-		}
+		stk[len(stk)-1].Next = cur
 		stk = append(stk, cur)
 	}
 	return dummy.Next
@@ -357,17 +343,13 @@ function removeNodes(head: ListNode | null): ListNode | null {
  */
 
 function removeNodes(head: ListNode | null): ListNode | null {
-    const dummy = new ListNode(0, head);
-    const stk: ListNode[] = [];
+    const dummy = new ListNode(Infinity, head);
+    const stk: ListNode[] = [dummy];
     for (let cur = head; cur; cur = cur.next) {
-        while (stk.length && stk.at(-1)!.val < cur.val) {
+        while (stk.at(-1)!.val < cur.val) {
             stk.pop();
         }
-        if (stk.length) {
-            stk.at(-1)!.next = cur;
-        } else {
-            dummy.next = cur;
-        }
+        stk.at(-1)!.next = cur;
         stk.push(cur);
     }
     return dummy.next;

solution/2400-2499/2487.Remove Nodes From Linked List/Solution.cpp

@@ -1,34 +1,26 @@
-/**
- * Definition for singly-linked list.
- * struct ListNode {
- *     int val;
- *     ListNode *next;
- *     ListNode() : val(0), next(nullptr) {}
- *     ListNode(int x) : val(x), next(nullptr) {}
- *     ListNode(int x, ListNode *next) : val(x), next(next) {}
- * };
- */
-class Solution {
-public:
-    ListNode* removeNodes(ListNode* head) {
-        vector<int> nums;
-        while (head) {
-            nums.emplace_back(head->val);
-            head = head->next;
-        }
-        vector<int> stk;
-        for (int v : nums) {
-            while (!stk.empty() && stk.back() < v) {
-                stk.pop_back();
-            }
-            stk.push_back(v);
-        }
-        ListNode* dummy = new ListNode();
-        head = dummy;
-        for (int v : stk) {
-            head->next = new ListNode(v);
-            head = head->next;
-        }
-        return dummy->next;
-    }
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeNodes(ListNode* head) {
+        ListNode* dummy = new ListNode(1e9, head);
+        ListNode* cur = head;
+        vector<ListNode*> stk = {dummy};
+        for (ListNode* cur = head; cur; cur = cur->next) {
+            while (stk.back()->val < cur->val) {
+                stk.pop_back();
+            }
+            stk.back()->next = cur;
+            stk.push_back(cur);
+        }
+        return dummy->next;
+    }
 };

solution/2400-2499/2487.Remove Nodes From Linked List/Solution.go

@@ -6,23 +6,14 @@
  * }
  */
 func removeNodes(head *ListNode) *ListNode {
-	nums := []int{}
-	for head != nil {
-		nums = append(nums, head.Val)
-		head = head.Next
-	}
-	stk := []int{}
-	for _, v := range nums {
-		for len(stk) > 0 && stk[len(stk)-1] < v {
+	dummy := &ListNode{1 << 30, head}
+	stk := []*ListNode{dummy}
+	for cur := head; cur != nil; cur = cur.Next {
+		for stk[len(stk)-1].Val < cur.Val {
 			stk = stk[:len(stk)-1]
 		}
-		stk = append(stk, v)
-	}
-	dummy := &ListNode{}
-	head = dummy
-	for _, v := range stk {
-		head.Next = &ListNode{Val: v}
-		head = head.Next
+		stk[len(stk)-1].Next = cur
+		stk = append(stk, cur)
 	}
 	return dummy.Next
 }

solution/2400-2499/2487.Remove Nodes From Linked List/Solution.java

@@ -10,23 +10,15 @@
  */
 class Solution {
     public ListNode removeNodes(ListNode head) {
-        List<Integer> nums = new ArrayList<>();
-        while (head != null) {
-            nums.add(head.val);
-            head = head.next;
-        }
-        Deque<Integer> stk = new ArrayDeque<>();
-        for (int v : nums) {
-            while (!stk.isEmpty() && stk.peekLast() < v) {
+        ListNode dummy = new ListNode(1 << 30, head);
+        Deque<ListNode> stk = new ArrayDeque<>();
+        stk.offerLast(dummy);
+        for (ListNode cur = head; cur != null; cur = cur.next) {
+            while (stk.peekLast().val < cur.val) {
                 stk.pollLast();
             }
-            stk.offerLast(v);
-        }
-        ListNode dummy = new ListNode();
-        head = dummy;
-        while (!stk.isEmpty()) {
-            head.next = new ListNode(stk.pollFirst());
-            head = head.next;
+            stk.peekLast().next = cur;
+            stk.offerLast(cur);
         }
         return dummy.next;
     }

solution/2400-2499/2487.Remove Nodes From Linked List/Solution.py

@@ -1,22 +1,17 @@
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
-    def removeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        nums = []
-        while head:
-            nums.append(head.val)
-            head = head.next
-        stk = []
-        for v in nums:
-            while stk and stk[-1] < v:
-                stk.pop()
-            stk.append(v)
-        dummy = ListNode()
-        head = dummy
-        for v in stk:
-            head.next = ListNode(v)
-            head = head.next
-        return dummy.next
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode(inf, head)
+        cur = head
+        stk = [dummy]
+        while cur:
+            while stk[-1].val < cur.val:
+                stk.pop()
+            stk[-1].next = cur
+            stk.append(cur)
+            cur = cur.next
+        return dummy.next