From bb02312c7f7fe081a74712f8251fe3b815ae9a92 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:50:41 +0530 Subject: [PATCH 01/18] feat: add solutions to lc problem: No.3013 --- .../README_EN.md | 51 ++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md index 6386882a88658..f40a1ae32d96d 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md @@ -67,7 +67,56 @@ It can be shown that there is no possible way to divide nums into 3 subarrays at ``` ```cpp - +class Solution { +public: + long long minimumCost(vector& nums, int k, int dist) { + multiset sml, big; + int sz = dist + 1; + long long sum = 0, ans = 0; + for(int i = 1; i <= sz; i++){ + sml.insert(nums[i]); + sum += nums[i]; + } + while(sml.size() > k-1){ + big.insert(*sml.rbegin()); + sum -= *sml.rbegin(); + sml.erase(sml.find(*sml.rbegin())); + } + ans = sum; + for(int i = sz+1; i < nums.size(); i++){ + sum += nums[i]; + sml.insert(nums[i]); + if(big.find(nums[i - sz]) != big.end()){ + big.erase(big.find(nums[i - sz])); + } + else{ + sum -= nums[i - sz]; + sml.erase(sml.find(nums[i - sz])); + } + + while(sml.size() > k-1){ + sum -= *sml.rbegin(); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + } + while(sml.size() < k-1){ + sum += *big.begin(); + sml.insert(*big.begin()); + big.erase(big.begin()); + } + while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + sum -= *sml.rbegin() - *big.begin(); + sml.insert(*big.begin()); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + big.erase(big.begin()); + } + ans = min(ans, sum); + } + int p = 0; + return nums[0] + ans; + } +}; ``` ```go From 972809668fecb466a833ab60ef0556a09f7a27f1 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:50:49 +0530 Subject: [PATCH 02/18] feat: add solutions to lc problem: No.3013 --- .../README.md | 51 ++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md index 5509361858284..54586d8d676ec 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md @@ -71,7 +71,56 @@ ``` ```cpp - +class Solution { +public: + long long minimumCost(vector& nums, int k, int dist) { + multiset sml, big; + int sz = dist + 1; + long long sum = 0, ans = 0; + for(int i = 1; i <= sz; i++){ + sml.insert(nums[i]); + sum += nums[i]; + } + while(sml.size() > k-1){ + big.insert(*sml.rbegin()); + sum -= *sml.rbegin(); + sml.erase(sml.find(*sml.rbegin())); + } + ans = sum; + for(int i = sz+1; i < nums.size(); i++){ + sum += nums[i]; + sml.insert(nums[i]); + if(big.find(nums[i - sz]) != big.end()){ + big.erase(big.find(nums[i - sz])); + } + else{ + sum -= nums[i - sz]; + sml.erase(sml.find(nums[i - sz])); + } + + while(sml.size() > k-1){ + sum -= *sml.rbegin(); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + } + while(sml.size() < k-1){ + sum += *big.begin(); + sml.insert(*big.begin()); + big.erase(big.begin()); + } + while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + sum -= *sml.rbegin() - *big.begin(); + sml.insert(*big.begin()); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + big.erase(big.begin()); + } + ans = min(ans, sum); + } + int p = 0; + return nums[0] + ans; + } +}; ``` ```go From 7ec973a7d720f13b2855aa92e477f5bf2555c293 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:50:56 +0530 Subject: [PATCH 03/18] feat: add solutions to lc problem: No.3013 --- .../Solution.cpp | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp new file mode 100644 index 0000000000000..6f2b0c0d1388c --- /dev/null +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp @@ -0,0 +1,50 @@ +class Solution { +public: + long long minimumCost(vector& nums, int k, int dist) { + multiset sml, big; + int sz = dist + 1; + long long sum = 0, ans = 0; + for(int i = 1; i <= sz; i++){ + sml.insert(nums[i]); + sum += nums[i]; + } + while(sml.size() > k-1){ + big.insert(*sml.rbegin()); + sum -= *sml.rbegin(); + sml.erase(sml.find(*sml.rbegin())); + } + ans = sum; + for(int i = sz+1; i < nums.size(); i++){ + sum += nums[i]; + sml.insert(nums[i]); + if(big.find(nums[i - sz]) != big.end()){ + big.erase(big.find(nums[i - sz])); + } + else{ + sum -= nums[i - sz]; + sml.erase(sml.find(nums[i - sz])); + } + + while(sml.size() > k-1){ + sum -= *sml.rbegin(); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + } + while(sml.size() < k-1){ + sum += *big.begin(); + sml.insert(*big.begin()); + big.erase(big.begin()); + } + while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + sum -= *sml.rbegin() - *big.begin(); + sml.insert(*big.begin()); + big.insert(*sml.rbegin()); + sml.erase(sml.find(*sml.rbegin())); + big.erase(big.begin()); + } + ans = min(ans, sum); + } + int p = 0; + return nums[0] + ans; + } +}; From 057df02a760cc2ffe7eca0accd491702f2f07cd6 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:53:31 +0530 Subject: [PATCH 04/18] feat: add solutions to lc problem: No.3013 --- .../Solution.py | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py new file mode 100644 index 0000000000000..5dd28cf648e2e --- /dev/null +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py @@ -0,0 +1,35 @@ +from sortedcontainers import SortedList +class Solution: + def minimumCost(self, nums: List[int], k: int, dist: int) -> int: + n=len(nums) + + sl = SortedList() + y = nums[0] + ans = float("inf") + i = 1 + running_sum = 0 + + for j in range(1, n): + pos = bisect.bisect_left(sl, nums[j]) + sl.add(nums[j]) + + if pos < k - 1: + running_sum += nums[j] + if len(sl) > k - 1: + running_sum -= sl[k-1] + + while j - i > dist: + removed_pos = sl.index(nums[i]) + removed_element = nums[i] + sl.remove(removed_element) + + if removed_pos < k - 1: + running_sum -= removed_element + if len(sl) >= k - 1: + running_sum += sl[k-2] + i += 1 + + if j - i + 1 >= k - 1: + ans = min(ans, running_sum) + + return ans + y From 877423d2c8cac1cd74d02a8b98bf8db8f38e73f9 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:54:58 +0530 Subject: [PATCH 05/18] feat: add solutions to lc problem: No.3013 --- .../Solution.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java new file mode 100644 index 0000000000000..c817a4aecb625 --- /dev/null +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java @@ -0,0 +1,39 @@ +class Solution { + public long minimumCost(int[] nums, int k, int dist) { + long result = Long.MAX_VALUE, sum = 0l; + int n = nums.length; + TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + for(int i=1;i=k) + { + int x=set1.pollLast(); + sum-=nums[x]; + set2.add(x); + } + if(i-dist>0) + { + result=Math.min(result,sum); + int temp=i-dist; + if(set1.contains(temp)) + { + set1.remove(temp); + sum-=nums[temp]; + if(set2.size()>0) + { + int y=set2.pollFirst(); + sum+=nums[y]; + set1.add(y); + } + } + else{ + set2.remove(i-dist); + } + } + } + return result+nums[0]; + } +} From eef8f62f5d99ed2c48755998b29c8eb11c8c271c Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:28:17 +0530 Subject: [PATCH 06/18] feat: add solutions to lc problem: No.3013 --- .../README.md | 76 ++++++++++++++++++- 1 file changed, 74 insertions(+), 2 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md index 54586d8d676ec..8f823ce629e99 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md @@ -63,11 +63,83 @@ ```python - +from sortedcontainers import SortedList +class Solution: + def minimumCost(self, nums: List[int], k: int, dist: int) -> int: + n=len(nums) + + sl = SortedList() + y = nums[0] + ans = float("inf") + i = 1 + running_sum = 0 + + for j in range(1, n): + pos = bisect.bisect_left(sl, nums[j]) + sl.add(nums[j]) + + if pos < k - 1: + running_sum += nums[j] + if len(sl) > k - 1: + running_sum -= sl[k-1] + + while j - i > dist: + removed_pos = sl.index(nums[i]) + removed_element = nums[i] + sl.remove(removed_element) + + if removed_pos < k - 1: + running_sum -= removed_element + if len(sl) >= k - 1: + running_sum += sl[k-2] + i += 1 + + if j - i + 1 >= k - 1: + ans = min(ans, running_sum) + + return ans + y ``` ```java - +class Solution { + public long minimumCost(int[] nums, int k, int dist) { + long result = Long.MAX_VALUE, sum = 0l; + int n = nums.length; + TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + for(int i=1;i=k) + { + int x=set1.pollLast(); + sum-=nums[x]; + set2.add(x); + } + if(i-dist>0) + { + result=Math.min(result,sum); + int temp=i-dist; + if(set1.contains(temp)) + { + set1.remove(temp); + sum-=nums[temp]; + if(set2.size()>0) + { + int y=set2.pollFirst(); + sum+=nums[y]; + set1.add(y); + } + } + else{ + set2.remove(i-dist); + } + } + } + return result+nums[0]; + } +} ``` ```cpp From 757232c0be0c6d4de68a31cb54cfa0f2f5f115d9 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:28:25 +0530 Subject: [PATCH 07/18] feat: add solutions to lc problem: No.3013 --- .../README_EN.md | 76 ++++++++++++++++++- 1 file changed, 74 insertions(+), 2 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md index f40a1ae32d96d..0fd958f809bd7 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md @@ -59,11 +59,83 @@ It can be shown that there is no possible way to divide nums into 3 subarrays at ```python - +from sortedcontainers import SortedList +class Solution: + def minimumCost(self, nums: List[int], k: int, dist: int) -> int: + n=len(nums) + + sl = SortedList() + y = nums[0] + ans = float("inf") + i = 1 + running_sum = 0 + + for j in range(1, n): + pos = bisect.bisect_left(sl, nums[j]) + sl.add(nums[j]) + + if pos < k - 1: + running_sum += nums[j] + if len(sl) > k - 1: + running_sum -= sl[k-1] + + while j - i > dist: + removed_pos = sl.index(nums[i]) + removed_element = nums[i] + sl.remove(removed_element) + + if removed_pos < k - 1: + running_sum -= removed_element + if len(sl) >= k - 1: + running_sum += sl[k-2] + i += 1 + + if j - i + 1 >= k - 1: + ans = min(ans, running_sum) + + return ans + y ``` ```java - +class Solution { + public long minimumCost(int[] nums, int k, int dist) { + long result = Long.MAX_VALUE, sum = 0l; + int n = nums.length; + TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + for(int i=1;i=k) + { + int x=set1.pollLast(); + sum-=nums[x]; + set2.add(x); + } + if(i-dist>0) + { + result=Math.min(result,sum); + int temp=i-dist; + if(set1.contains(temp)) + { + set1.remove(temp); + sum-=nums[temp]; + if(set2.size()>0) + { + int y=set2.pollFirst(); + sum+=nums[y]; + set1.add(y); + } + } + else{ + set2.remove(i-dist); + } + } + } + return result+nums[0]; + } +} ``` ```cpp From 312d44e83a97b825e8627be28b95786675e60571 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:36:46 +0530 Subject: [PATCH 08/18] feat: add solutions to lc problem: No.3013 --- .../Solution.go | 204 ++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go new file mode 100644 index 0000000000000..8d7f03279b936 --- /dev/null +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go @@ -0,0 +1,204 @@ +func minimumCost(nums []int, k int, dist int) int64 { + res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + return int64(res) +} + +func mins(nums ...int) int { + res := nums[0] + for _, num := range nums { + if num < res { + res = num + } + } + return res +} + +func windowTopKSum(nums []int, windowSize, k int, min bool) []int { + n := len(nums) + ts := NewTopKSum(k, min) + res := []int{} + for right := 0; right < n; right++ { + ts.Add(nums[right]) + if right >= windowSize { + ts.Discard(nums[right-windowSize]) + } + if right >= windowSize-1 { + res = append(res, ts.Query()) + } + } + return res +} + +type TopKSum struct { + sum int + k int + in *Heap + out *Heap + dIn *Heap + dOut *Heap + counter map[int]int +} + +func NewTopKSum(k int, min bool) *TopKSum { + var less func(a, b int) bool + if min { + less = func(a, b int) bool { return a < b } + } else { + less = func(a, b int) bool { return a > b } + } + return &TopKSum{ + k: k, + in: NewHeap(less), + out: NewHeap(less), + dIn: NewHeap(less), + dOut: NewHeap(less), + counter: map[int]int{}, + } +} + +func (t *TopKSum) Query() int { + return t.sum +} + +func (t *TopKSum) Add(x int) { + t.counter[x]++ + t.in.Push(-x) + t.sum += x + t.modify() +} + +func (t *TopKSum) Discard(x int) bool { + if t.counter[x] == 0 { + return false + } + t.counter[x]-- + if t.in.Len() > 0 && -t.in.Top() == x { + t.sum -= x + t.in.Pop() + } else if t.in.Len() > 0 && -t.in.Top() > x { + t.sum -= x + t.dIn.Push(-x) + } else { + t.dOut.Push(x) + } + t.modify() + return true +} + +func (t *TopKSum) SetK(k int) { + t.k = k + t.modify() +} + +func (t *TopKSum) GetK() int { + return t.k +} + +func (t *TopKSum) Len() int { + return t.in.Len() + t.out.Len() - t.dIn.Len() - t.dOut.Len() +} + +func (t *TopKSum) Has(x int) bool { + return t.counter[x] > 0 +} + +func (t *TopKSum) modify() { + for t.out.Len() > 0 && (t.in.Len()-t.dIn.Len() < t.k) { + p := t.out.Pop() + if t.dOut.Len() > 0 && p == t.dOut.Top() { + t.dOut.Pop() + } else { + t.sum += p + t.in.Push(-p) + } + } + + for t.in.Len()-t.dIn.Len() > t.k { + p := -t.in.Pop() + if t.dIn.Len() > 0 && p == -t.dIn.Top() { + t.dIn.Pop() + } else { + t.sum -= p + t.out.Push(p) + } + } + + for t.dIn.Len() > 0 && t.in.Top() == t.dIn.Top() { + t.in.Pop() + t.dIn.Pop() + } +} + +type H = int + +func NewHeap(less func(a, b H) bool, nums ...H) *Heap { + nums = append(nums[:0:0], nums...) + heap := &Heap{less: less, data: nums} + heap.heapify() + return heap +} + +type Heap struct { + data []H + less func(a, b H) bool +} + +func (h *Heap) Push(value H) { + h.data = append(h.data, value) + h.pushUp(h.Len() - 1) +} + +func (h *Heap) Pop() (value H) { + if h.Len() == 0 { + panic("heap is empty") + } + + value = h.data[0] + h.data[0] = h.data[h.Len()-1] + h.data = h.data[:h.Len()-1] + h.pushDown(0) + return +} + +func (h *Heap) Top() (value H) { + value = h.data[0] + return +} + +func (h *Heap) Len() int { return len(h.data) } + +func (h *Heap) heapify() { + n := h.Len() + for i := (n >> 1) - 1; i > -1; i-- { + h.pushDown(i) + } +} + +func (h *Heap) pushUp(root int) { + for parent := (root - 1) >> 1; parent >= 0 && h.less(h.data[root], h.data[parent]); parent = (root - 1) >> 1 { + h.data[root], h.data[parent] = h.data[parent], h.data[root] + root = parent + } +} + +func (h *Heap) pushDown(root int) { + n := h.Len() + for left := (root<<1 + 1); left < n; left = (root<<1 + 1) { + right := left + 1 + minIndex := root + + if h.less(h.data[left], h.data[minIndex]) { + minIndex = left + } + + if right < n && h.less(h.data[right], h.data[minIndex]) { + minIndex = right + } + + if minIndex == root { + return + } + h.data[root], h.data[minIndex] = h.data[minIndex], h.data[root] + root = minIndex + } +} From 6820a2316e101e77013073076f33310cf49f2e57 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:37:33 +0530 Subject: [PATCH 09/18] feat: add solutions to lc problem: No.3013 --- .../README.md | 203 ++++++++++++++++++ 1 file changed, 203 insertions(+) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md index 8f823ce629e99..ee18af058c9bf 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md @@ -196,7 +196,210 @@ public: ``` ```go +func minimumCost(nums []int, k int, dist int) int64 { + res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + return int64(res) +} + +func mins(nums ...int) int { + res := nums[0] + for _, num := range nums { + if num < res { + res = num + } + } + return res +} + +func windowTopKSum(nums []int, windowSize, k int, min bool) []int { + n := len(nums) + ts := NewTopKSum(k, min) + res := []int{} + for right := 0; right < n; right++ { + ts.Add(nums[right]) + if right >= windowSize { + ts.Discard(nums[right-windowSize]) + } + if right >= windowSize-1 { + res = append(res, ts.Query()) + } + } + return res +} + +type TopKSum struct { + sum int + k int + in *Heap + out *Heap + dIn *Heap + dOut *Heap + counter map[int]int +} + +func NewTopKSum(k int, min bool) *TopKSum { + var less func(a, b int) bool + if min { + less = func(a, b int) bool { return a < b } + } else { + less = func(a, b int) bool { return a > b } + } + return &TopKSum{ + k: k, + in: NewHeap(less), + out: NewHeap(less), + dIn: NewHeap(less), + dOut: NewHeap(less), + counter: map[int]int{}, + } +} + +func (t *TopKSum) Query() int { + return t.sum +} +func (t *TopKSum) Add(x int) { + t.counter[x]++ + t.in.Push(-x) + t.sum += x + t.modify() +} + +func (t *TopKSum) Discard(x int) bool { + if t.counter[x] == 0 { + return false + } + t.counter[x]-- + if t.in.Len() > 0 && -t.in.Top() == x { + t.sum -= x + t.in.Pop() + } else if t.in.Len() > 0 && -t.in.Top() > x { + t.sum -= x + t.dIn.Push(-x) + } else { + t.dOut.Push(x) + } + t.modify() + return true +} + +func (t *TopKSum) SetK(k int) { + t.k = k + t.modify() +} + +func (t *TopKSum) GetK() int { + return t.k +} + +func (t *TopKSum) Len() int { + return t.in.Len() + t.out.Len() - t.dIn.Len() - t.dOut.Len() +} + +func (t *TopKSum) Has(x int) bool { + return t.counter[x] > 0 +} + +func (t *TopKSum) modify() { + for t.out.Len() > 0 && (t.in.Len()-t.dIn.Len() < t.k) { + p := t.out.Pop() + if t.dOut.Len() > 0 && p == t.dOut.Top() { + t.dOut.Pop() + } else { + t.sum += p + t.in.Push(-p) + } + } + + for t.in.Len()-t.dIn.Len() > t.k { + p := -t.in.Pop() + if t.dIn.Len() > 0 && p == -t.dIn.Top() { + t.dIn.Pop() + } else { + t.sum -= p + t.out.Push(p) + } + } + + for t.dIn.Len() > 0 && t.in.Top() == t.dIn.Top() { + t.in.Pop() + t.dIn.Pop() + } +} + +type H = int + +func NewHeap(less func(a, b H) bool, nums ...H) *Heap { + nums = append(nums[:0:0], nums...) + heap := &Heap{less: less, data: nums} + heap.heapify() + return heap +} + +type Heap struct { + data []H + less func(a, b H) bool +} + +func (h *Heap) Push(value H) { + h.data = append(h.data, value) + h.pushUp(h.Len() - 1) +} + +func (h *Heap) Pop() (value H) { + if h.Len() == 0 { + panic("heap is empty") + } + + value = h.data[0] + h.data[0] = h.data[h.Len()-1] + h.data = h.data[:h.Len()-1] + h.pushDown(0) + return +} + +func (h *Heap) Top() (value H) { + value = h.data[0] + return +} + +func (h *Heap) Len() int { return len(h.data) } + +func (h *Heap) heapify() { + n := h.Len() + for i := (n >> 1) - 1; i > -1; i-- { + h.pushDown(i) + } +} + +func (h *Heap) pushUp(root int) { + for parent := (root - 1) >> 1; parent >= 0 && h.less(h.data[root], h.data[parent]); parent = (root - 1) >> 1 { + h.data[root], h.data[parent] = h.data[parent], h.data[root] + root = parent + } +} + +func (h *Heap) pushDown(root int) { + n := h.Len() + for left := (root<<1 + 1); left < n; left = (root<<1 + 1) { + right := left + 1 + minIndex := root + + if h.less(h.data[left], h.data[minIndex]) { + minIndex = left + } + + if right < n && h.less(h.data[right], h.data[minIndex]) { + minIndex = right + } + + if minIndex == root { + return + } + h.data[root], h.data[minIndex] = h.data[minIndex], h.data[root] + root = minIndex + } +} ``` From ba6554e7a7b4c819192555090eb1f88970cda659 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:37:39 +0530 Subject: [PATCH 10/18] feat: add solutions to lc problem: No.3013 --- .../README_EN.md | 203 ++++++++++++++++++ 1 file changed, 203 insertions(+) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md index 0fd958f809bd7..372431a0a8312 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md @@ -192,7 +192,210 @@ public: ``` ```go +func minimumCost(nums []int, k int, dist int) int64 { + res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + return int64(res) +} + +func mins(nums ...int) int { + res := nums[0] + for _, num := range nums { + if num < res { + res = num + } + } + return res +} + +func windowTopKSum(nums []int, windowSize, k int, min bool) []int { + n := len(nums) + ts := NewTopKSum(k, min) + res := []int{} + for right := 0; right < n; right++ { + ts.Add(nums[right]) + if right >= windowSize { + ts.Discard(nums[right-windowSize]) + } + if right >= windowSize-1 { + res = append(res, ts.Query()) + } + } + return res +} + +type TopKSum struct { + sum int + k int + in *Heap + out *Heap + dIn *Heap + dOut *Heap + counter map[int]int +} + +func NewTopKSum(k int, min bool) *TopKSum { + var less func(a, b int) bool + if min { + less = func(a, b int) bool { return a < b } + } else { + less = func(a, b int) bool { return a > b } + } + return &TopKSum{ + k: k, + in: NewHeap(less), + out: NewHeap(less), + dIn: NewHeap(less), + dOut: NewHeap(less), + counter: map[int]int{}, + } +} + +func (t *TopKSum) Query() int { + return t.sum +} + +func (t *TopKSum) Add(x int) { + t.counter[x]++ + t.in.Push(-x) + t.sum += x + t.modify() +} + +func (t *TopKSum) Discard(x int) bool { + if t.counter[x] == 0 { + return false + } + t.counter[x]-- + if t.in.Len() > 0 && -t.in.Top() == x { + t.sum -= x + t.in.Pop() + } else if t.in.Len() > 0 && -t.in.Top() > x { + t.sum -= x + t.dIn.Push(-x) + } else { + t.dOut.Push(x) + } + t.modify() + return true +} + +func (t *TopKSum) SetK(k int) { + t.k = k + t.modify() +} + +func (t *TopKSum) GetK() int { + return t.k +} + +func (t *TopKSum) Len() int { + return t.in.Len() + t.out.Len() - t.dIn.Len() - t.dOut.Len() +} + +func (t *TopKSum) Has(x int) bool { + return t.counter[x] > 0 +} + +func (t *TopKSum) modify() { + for t.out.Len() > 0 && (t.in.Len()-t.dIn.Len() < t.k) { + p := t.out.Pop() + if t.dOut.Len() > 0 && p == t.dOut.Top() { + t.dOut.Pop() + } else { + t.sum += p + t.in.Push(-p) + } + } + for t.in.Len()-t.dIn.Len() > t.k { + p := -t.in.Pop() + if t.dIn.Len() > 0 && p == -t.dIn.Top() { + t.dIn.Pop() + } else { + t.sum -= p + t.out.Push(p) + } + } + + for t.dIn.Len() > 0 && t.in.Top() == t.dIn.Top() { + t.in.Pop() + t.dIn.Pop() + } +} + +type H = int + +func NewHeap(less func(a, b H) bool, nums ...H) *Heap { + nums = append(nums[:0:0], nums...) + heap := &Heap{less: less, data: nums} + heap.heapify() + return heap +} + +type Heap struct { + data []H + less func(a, b H) bool +} + +func (h *Heap) Push(value H) { + h.data = append(h.data, value) + h.pushUp(h.Len() - 1) +} + +func (h *Heap) Pop() (value H) { + if h.Len() == 0 { + panic("heap is empty") + } + + value = h.data[0] + h.data[0] = h.data[h.Len()-1] + h.data = h.data[:h.Len()-1] + h.pushDown(0) + return +} + +func (h *Heap) Top() (value H) { + value = h.data[0] + return +} + +func (h *Heap) Len() int { return len(h.data) } + +func (h *Heap) heapify() { + n := h.Len() + for i := (n >> 1) - 1; i > -1; i-- { + h.pushDown(i) + } +} + +func (h *Heap) pushUp(root int) { + for parent := (root - 1) >> 1; parent >= 0 && h.less(h.data[root], h.data[parent]); parent = (root - 1) >> 1 { + h.data[root], h.data[parent] = h.data[parent], h.data[root] + root = parent + } +} + +func (h *Heap) pushDown(root int) { + n := h.Len() + for left := (root<<1 + 1); left < n; left = (root<<1 + 1) { + right := left + 1 + minIndex := root + + if h.less(h.data[left], h.data[minIndex]) { + minIndex = left + } + + if right < n && h.less(h.data[right], h.data[minIndex]) { + minIndex = right + } + + if minIndex == root { + return + } + h.data[root], h.data[minIndex] = h.data[minIndex], h.data[root] + root = minIndex + } +} ``` From a52823ff532746a24a8e885961442cf54fd72db8 Mon Sep 17 00:00:00 2001 From: Nothing-avil Date: Mon, 22 Jan 2024 14:16:32 +0000 Subject: [PATCH 11/18] style: format code and docs with prettier --- .../README.md | 6 +++--- .../README_EN.md | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md index ee18af058c9bf..534cc63116812 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md @@ -77,7 +77,7 @@ class Solution: for j in range(1, n): pos = bisect.bisect_left(sl, nums[j]) sl.add(nums[j]) - + if pos < k - 1: running_sum += nums[j] if len(sl) > k - 1: @@ -87,7 +87,7 @@ class Solution: removed_pos = sl.index(nums[i]) removed_element = nums[i] sl.remove(removed_element) - + if removed_pos < k - 1: running_sum -= removed_element if len(sl) >= k - 1: @@ -169,7 +169,7 @@ public: sum -= nums[i - sz]; sml.erase(sml.find(nums[i - sz])); } - + while(sml.size() > k-1){ sum -= *sml.rbegin(); big.insert(*sml.rbegin()); diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md index 372431a0a8312..7236ce1f06207 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md @@ -73,7 +73,7 @@ class Solution: for j in range(1, n): pos = bisect.bisect_left(sl, nums[j]) sl.add(nums[j]) - + if pos < k - 1: running_sum += nums[j] if len(sl) > k - 1: @@ -83,7 +83,7 @@ class Solution: removed_pos = sl.index(nums[i]) removed_element = nums[i] sl.remove(removed_element) - + if removed_pos < k - 1: running_sum -= removed_element if len(sl) >= k - 1: @@ -165,7 +165,7 @@ public: sum -= nums[i - sz]; sml.erase(sml.find(nums[i - sz])); } - + while(sml.size() > k-1){ sum -= *sml.rbegin(); big.insert(*sml.rbegin()); From fd30b45ef77e6c7fe8bda31f16f5bfcb59740e32 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:22:46 +0800 Subject: [PATCH 12/18] Update Solution.py --- .../Solution.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py index 5dd28cf648e2e..65c662dd29643 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.py @@ -1,7 +1,9 @@ from sortedcontainers import SortedList + + class Solution: def minimumCost(self, nums: List[int], k: int, dist: int) -> int: - n=len(nums) + n = len(nums) sl = SortedList() y = nums[0] @@ -12,21 +14,21 @@ def minimumCost(self, nums: List[int], k: int, dist: int) -> int: for j in range(1, n): pos = bisect.bisect_left(sl, nums[j]) sl.add(nums[j]) - + if pos < k - 1: running_sum += nums[j] if len(sl) > k - 1: - running_sum -= sl[k-1] + running_sum -= sl[k - 1] while j - i > dist: removed_pos = sl.index(nums[i]) removed_element = nums[i] sl.remove(removed_element) - + if removed_pos < k - 1: running_sum -= removed_element if len(sl) >= k - 1: - running_sum += sl[k-2] + running_sum += sl[k - 2] i += 1 if j - i + 1 >= k - 1: From 3cada48ab0bac2385f96deaeab4e15daecd13e26 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:24:10 +0800 Subject: [PATCH 13/18] Update Solution.java --- .../Solution.java | 40 ++++++++----------- 1 file changed, 17 insertions(+), 23 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java index c817a4aecb625..22ffdf73048d6 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java @@ -1,39 +1,33 @@ class Solution { public long minimumCost(int[] nums, int k, int dist) { - long result = Long.MAX_VALUE, sum = 0l; + long result = Long.MAX_VALUE, sum = 0L; int n = nums.length; TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - for(int i=1;i=k) - { - int x=set1.pollLast(); - sum-=nums[x]; + sum += nums[i]; + if (set1.size() >= k) { + int x = set1.pollLast(); + sum -= nums[x]; set2.add(x); } - if(i-dist>0) - { - result=Math.min(result,sum); - int temp=i-dist; - if(set1.contains(temp)) - { + if (i - dist > 0) { + result = Math.min(result, sum); + int temp = i - dist; + if (set1.contains(temp)) { set1.remove(temp); - sum-=nums[temp]; - if(set2.size()>0) - { - int y=set2.pollFirst(); - sum+=nums[y]; + sum -= nums[temp]; + if (set2.size() > 0) { + int y = set2.pollFirst(); + sum += nums[y]; set1.add(y); } - } - else{ - set2.remove(i-dist); + } else { + set2.remove(i - dist); } } } - return result+nums[0]; + return result + nums[0]; } } From 683a103902da2c4e15f650b895715bfce0a95943 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:25:07 +0800 Subject: [PATCH 14/18] Update Solution.cpp --- .../Solution.cpp | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp index 6f2b0c0d1388c..0308b08a80d4f 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.cpp @@ -4,38 +4,37 @@ class Solution { multiset sml, big; int sz = dist + 1; long long sum = 0, ans = 0; - for(int i = 1; i <= sz; i++){ + for (int i = 1; i <= sz; i++) { sml.insert(nums[i]); sum += nums[i]; } - while(sml.size() > k-1){ + while (sml.size() > k - 1) { big.insert(*sml.rbegin()); sum -= *sml.rbegin(); sml.erase(sml.find(*sml.rbegin())); } ans = sum; - for(int i = sz+1; i < nums.size(); i++){ + for (int i = sz + 1; i < nums.size(); i++) { sum += nums[i]; sml.insert(nums[i]); - if(big.find(nums[i - sz]) != big.end()){ + if (big.find(nums[i - sz]) != big.end()) { big.erase(big.find(nums[i - sz])); - } - else{ + } else { sum -= nums[i - sz]; sml.erase(sml.find(nums[i - sz])); } - - while(sml.size() > k-1){ + + while (sml.size() > k - 1) { sum -= *sml.rbegin(); big.insert(*sml.rbegin()); sml.erase(sml.find(*sml.rbegin())); } - while(sml.size() < k-1){ + while (sml.size() < k - 1) { sum += *big.begin(); sml.insert(*big.begin()); big.erase(big.begin()); } - while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + while (!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()) { sum -= *sml.rbegin() - *big.begin(); sml.insert(*big.begin()); big.insert(*sml.rbegin()); From 2c1c2146149290200edb7e526144c940fc1ec468 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:27:00 +0800 Subject: [PATCH 15/18] Update Solution.go --- .../Solution.go | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go index 8d7f03279b936..90c0f82e10c30 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.go @@ -1,18 +1,8 @@ func minimumCost(nums []int, k int, dist int) int64 { - res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + res := nums[0] + slices.Min(windowTopKSum(nums[1:], dist+1, k-1, true)) return int64(res) } -func mins(nums ...int) int { - res := nums[0] - for _, num := range nums { - if num < res { - res = num - } - } - return res -} - func windowTopKSum(nums []int, windowSize, k int, min bool) []int { n := len(nums) ts := NewTopKSum(k, min) From be20b5067bcc972799f2c2ecf8189c0e7bab5bd1 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:28:12 +0800 Subject: [PATCH 16/18] Update Solution.java --- .../Solution.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java index 22ffdf73048d6..5a84a1f392c9a 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/Solution.java @@ -2,8 +2,10 @@ class Solution { public long minimumCost(int[] nums, int k, int dist) { long result = Long.MAX_VALUE, sum = 0L; int n = nums.length; - TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set1 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); for (int i = 1; i < n; i++) { set1.add(i); sum += nums[i]; From 7de3a29cf68298f3cd314fc52ce3589eab7ff39d Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:29:52 +0800 Subject: [PATCH 17/18] Update README.md --- .../README.md | 83 ++++++++----------- 1 file changed, 35 insertions(+), 48 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md index 534cc63116812..c50f4e7cfea20 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md @@ -64,9 +64,11 @@ ```python from sortedcontainers import SortedList + + class Solution: def minimumCost(self, nums: List[int], k: int, dist: int) -> int: - n=len(nums) + n = len(nums) sl = SortedList() y = nums[0] @@ -81,7 +83,7 @@ class Solution: if pos < k - 1: running_sum += nums[j] if len(sl) > k - 1: - running_sum -= sl[k-1] + running_sum -= sl[k - 1] while j - i > dist: removed_pos = sl.index(nums[i]) @@ -91,7 +93,7 @@ class Solution: if removed_pos < k - 1: running_sum -= removed_element if len(sl) >= k - 1: - running_sum += sl[k-2] + running_sum += sl[k - 2] i += 1 if j - i + 1 >= k - 1: @@ -103,41 +105,37 @@ class Solution: ```java class Solution { public long minimumCost(int[] nums, int k, int dist) { - long result = Long.MAX_VALUE, sum = 0l; + long result = Long.MAX_VALUE, sum = 0L; int n = nums.length; - TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - for(int i=1;i set1 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + for (int i = 1; i < n; i++) { set1.add(i); - sum+=nums[i]; - if(set1.size()>=k) - { - int x=set1.pollLast(); - sum-=nums[x]; + sum += nums[i]; + if (set1.size() >= k) { + int x = set1.pollLast(); + sum -= nums[x]; set2.add(x); } - if(i-dist>0) - { - result=Math.min(result,sum); - int temp=i-dist; - if(set1.contains(temp)) - { + if (i - dist > 0) { + result = Math.min(result, sum); + int temp = i - dist; + if (set1.contains(temp)) { set1.remove(temp); - sum-=nums[temp]; - if(set2.size()>0) - { - int y=set2.pollFirst(); - sum+=nums[y]; + sum -= nums[temp]; + if (set2.size() > 0) { + int y = set2.pollFirst(); + sum += nums[y]; set1.add(y); } - } - else{ - set2.remove(i-dist); + } else { + set2.remove(i - dist); } } } - return result+nums[0]; + return result + nums[0]; } } ``` @@ -149,38 +147,37 @@ public: multiset sml, big; int sz = dist + 1; long long sum = 0, ans = 0; - for(int i = 1; i <= sz; i++){ + for (int i = 1; i <= sz; i++) { sml.insert(nums[i]); sum += nums[i]; } - while(sml.size() > k-1){ + while (sml.size() > k - 1) { big.insert(*sml.rbegin()); sum -= *sml.rbegin(); sml.erase(sml.find(*sml.rbegin())); } ans = sum; - for(int i = sz+1; i < nums.size(); i++){ + for (int i = sz + 1; i < nums.size(); i++) { sum += nums[i]; sml.insert(nums[i]); - if(big.find(nums[i - sz]) != big.end()){ + if (big.find(nums[i - sz]) != big.end()) { big.erase(big.find(nums[i - sz])); - } - else{ + } else { sum -= nums[i - sz]; sml.erase(sml.find(nums[i - sz])); } - while(sml.size() > k-1){ + while (sml.size() > k - 1) { sum -= *sml.rbegin(); big.insert(*sml.rbegin()); sml.erase(sml.find(*sml.rbegin())); } - while(sml.size() < k-1){ + while (sml.size() < k - 1) { sum += *big.begin(); sml.insert(*big.begin()); big.erase(big.begin()); } - while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + while (!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()) { sum -= *sml.rbegin() - *big.begin(); sml.insert(*big.begin()); big.insert(*sml.rbegin()); @@ -197,20 +194,10 @@ public: ```go func minimumCost(nums []int, k int, dist int) int64 { - res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + res := nums[0] + slices.Min(windowTopKSum(nums[1:], dist+1, k-1, true)) return int64(res) } -func mins(nums ...int) int { - res := nums[0] - for _, num := range nums { - if num < res { - res = num - } - } - return res -} - func windowTopKSum(nums []int, windowSize, k int, min bool) []int { n := len(nums) ts := NewTopKSum(k, min) From e5474a872dfe91a4b6dc7a2a898e32fa201f36fc Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 23 Jan 2024 09:30:38 +0800 Subject: [PATCH 18/18] Update README_EN.md --- .../README_EN.md | 83 ++++++++----------- 1 file changed, 35 insertions(+), 48 deletions(-) diff --git a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md index 7236ce1f06207..c1e4a8d0e51c5 100644 --- a/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md +++ b/solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md @@ -60,9 +60,11 @@ It can be shown that there is no possible way to divide nums into 3 subarrays at ```python from sortedcontainers import SortedList + + class Solution: def minimumCost(self, nums: List[int], k: int, dist: int) -> int: - n=len(nums) + n = len(nums) sl = SortedList() y = nums[0] @@ -77,7 +79,7 @@ class Solution: if pos < k - 1: running_sum += nums[j] if len(sl) > k - 1: - running_sum -= sl[k-1] + running_sum -= sl[k - 1] while j - i > dist: removed_pos = sl.index(nums[i]) @@ -87,7 +89,7 @@ class Solution: if removed_pos < k - 1: running_sum -= removed_element if len(sl) >= k - 1: - running_sum += sl[k-2] + running_sum += sl[k - 2] i += 1 if j - i + 1 >= k - 1: @@ -99,41 +101,37 @@ class Solution: ```java class Solution { public long minimumCost(int[] nums, int k, int dist) { - long result = Long.MAX_VALUE, sum = 0l; + long result = Long.MAX_VALUE, sum = 0L; int n = nums.length; - TreeSet set1 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - TreeSet set2 = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); - for(int i=1;i set1 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + TreeSet set2 + = new TreeSet<>((a, b) -> nums[a] == nums[b] ? a - b : nums[a] - nums[b]); + for (int i = 1; i < n; i++) { set1.add(i); - sum+=nums[i]; - if(set1.size()>=k) - { - int x=set1.pollLast(); - sum-=nums[x]; + sum += nums[i]; + if (set1.size() >= k) { + int x = set1.pollLast(); + sum -= nums[x]; set2.add(x); } - if(i-dist>0) - { - result=Math.min(result,sum); - int temp=i-dist; - if(set1.contains(temp)) - { + if (i - dist > 0) { + result = Math.min(result, sum); + int temp = i - dist; + if (set1.contains(temp)) { set1.remove(temp); - sum-=nums[temp]; - if(set2.size()>0) - { - int y=set2.pollFirst(); - sum+=nums[y]; + sum -= nums[temp]; + if (set2.size() > 0) { + int y = set2.pollFirst(); + sum += nums[y]; set1.add(y); } - } - else{ - set2.remove(i-dist); + } else { + set2.remove(i - dist); } } } - return result+nums[0]; + return result + nums[0]; } } ``` @@ -145,38 +143,37 @@ public: multiset sml, big; int sz = dist + 1; long long sum = 0, ans = 0; - for(int i = 1; i <= sz; i++){ + for (int i = 1; i <= sz; i++) { sml.insert(nums[i]); sum += nums[i]; } - while(sml.size() > k-1){ + while (sml.size() > k - 1) { big.insert(*sml.rbegin()); sum -= *sml.rbegin(); sml.erase(sml.find(*sml.rbegin())); } ans = sum; - for(int i = sz+1; i < nums.size(); i++){ + for (int i = sz + 1; i < nums.size(); i++) { sum += nums[i]; sml.insert(nums[i]); - if(big.find(nums[i - sz]) != big.end()){ + if (big.find(nums[i - sz]) != big.end()) { big.erase(big.find(nums[i - sz])); - } - else{ + } else { sum -= nums[i - sz]; sml.erase(sml.find(nums[i - sz])); } - while(sml.size() > k-1){ + while (sml.size() > k - 1) { sum -= *sml.rbegin(); big.insert(*sml.rbegin()); sml.erase(sml.find(*sml.rbegin())); } - while(sml.size() < k-1){ + while (sml.size() < k - 1) { sum += *big.begin(); sml.insert(*big.begin()); big.erase(big.begin()); } - while(!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()){ + while (!sml.empty() && !big.empty() && *sml.rbegin() > *big.begin()) { sum -= *sml.rbegin() - *big.begin(); sml.insert(*big.begin()); big.insert(*sml.rbegin()); @@ -193,20 +190,10 @@ public: ```go func minimumCost(nums []int, k int, dist int) int64 { - res := nums[0] + mins((windowTopKSum(nums[1:], dist+1, k-1, true))...) + res := nums[0] + slices.Min(windowTopKSum(nums[1:], dist+1, k-1, true)) return int64(res) } -func mins(nums ...int) int { - res := nums[0] - for _, num := range nums { - if num < res { - res = num - } - } - return res -} - func windowTopKSum(nums []int, windowSize, k int, min bool) []int { n := len(nums) ts := NewTopKSum(k, min)