From 5920db5fa861ba582684f19dffcf73ff71ad50f9 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 5 Aug 2025 07:04:30 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.3479 (#4621) No.3479.Fruits Into Baskets III --- .../3479.Fruits Into Baskets III/README.md | 431 +++++++++++++++++- .../3479.Fruits Into Baskets III/README_EN.md | 431 +++++++++++++++++- .../3479.Fruits Into Baskets III/Solution.cpp | 72 +++ .../3479.Fruits Into Baskets III/Solution.go | 70 +++ .../Solution.java | 71 +++ .../3479.Fruits Into Baskets III/Solution.py | 55 +++ .../3479.Fruits Into Baskets III/Solution.rs | 76 +++ .../3479.Fruits Into Baskets III/Solution.ts | 69 +++ 8 files changed, 1267 insertions(+), 8 deletions(-) create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.cpp create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.go create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.java create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.py create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.rs create mode 100644 solution/3400-3499/3479.Fruits Into Baskets III/Solution.ts diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/README.md b/solution/3400-3499/3479.Fruits Into Baskets III/README.md index 48665b00b4a75..14098f6839119 100644 --- a/solution/3400-3499/3479.Fruits Into Baskets III/README.md +++ b/solution/3400-3499/3479.Fruits Into Baskets III/README.md @@ -88,32 +88,455 @@ tags: -### 方法一 +### 方法一：线段树二分 + +我们可以用线段树来维护区间里的篮子容量的最大值，这样可以通过二分查找，快速找到第一个容量大于等于水果数量的篮子。如果找不到这样的篮子，答案加一；如果找到了，就将该篮子的容量置为零，表示这个篮子已经被使用了。 + +时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为 $\textit{baskets}$ 的长度。 #### Python3 ```python - +class SegmentTree: + __slots__ = ["nums", "tr"] + + def __init__(self, nums): + self.nums = nums + n = len(nums) + self.tr = [0] * (n << 2) + self.build(1, 1, n) + + def build(self, u, l, r): + if l == r: + self.tr[u] = self.nums[l - 1] + return + mid = (l + r) >> 1 + self.build(u << 1, l, mid) + self.build(u << 1 | 1, mid + 1, r) + self.pushup(u) + + def modify(self, u, l, r, i, v): + if l == r: + self.tr[u] = v + return + mid = (l + r) >> 1 + if i <= mid: + self.modify(u << 1, l, mid, i, v) + else: + self.modify(u << 1 | 1, mid + 1, r, i, v) + self.pushup(u) + + def query(self, u, l, r, v): + if self.tr[u] < v: + return -1 + if l == r: + return l + mid = (l + r) >> 1 + if self.tr[u << 1] >= v: + return self.query(u << 1, l, mid, v) + return self.query(u << 1 | 1, mid + 1, r, v) + + def pushup(self, u): + self.tr[u] = max(self.tr[u << 1], self.tr[u << 1 | 1]) + + +class Solution: + def numOfUnplacedFruits(self, fruits: List[int], baskets: List[int]) -> int: + tree = SegmentTree(baskets) + n = len(baskets) + ans = 0 + for x in fruits: + i = tree.query(1, 1, n, x) + if i < 0: + ans += 1 + else: + tree.modify(1, 1, n, i, 0) + return ans ``` #### Java ```java - +class SegmentTree { + int[] nums; + int[] tr; + + public SegmentTree(int[] nums) { + this.nums = nums; + int n = nums.length; + this.tr = new int[n << 2]; + build(1, 1, n); + } + + public void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u << 1, l, mid); + build(u << 1 | 1, mid + 1, r); + pushup(u); + } + + public void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u << 1, l, mid, i, v); + } else { + modify(u << 1 | 1, mid + 1, r, i, v); + } + pushup(u); + } + + public int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u << 1] >= v) { + return query(u << 1, l, mid, v); + } + return query(u << 1 | 1, mid + 1, r, v); + } + + public void pushup(int u) { + tr[u] = Math.max(tr[u << 1], tr[u << 1 | 1]); + } +} + +class Solution { + public int numOfUnplacedFruits(int[] fruits, int[] baskets) { + SegmentTree tree = new SegmentTree(baskets); + int n = baskets.length; + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +} ``` #### C++ ```cpp - +class SegmentTree { +public: + vector nums, tr; + + SegmentTree(vector& nums) { + this->nums = nums; + int n = nums.size(); + tr.resize(n * 4); + build(1, 1, n); + } + + void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u * 2, l, mid); + build(u * 2 + 1, mid + 1, r); + pushup(u); + } + + void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u * 2, l, mid, i, v); + } else { + modify(u * 2 + 1, mid + 1, r, i, v); + } + pushup(u); + } + + int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u * 2] >= v) { + return query(u * 2, l, mid, v); + } + return query(u * 2 + 1, mid + 1, r, v); + } + + void pushup(int u) { + tr[u] = max(tr[u * 2], tr[u * 2 + 1]); + } +}; + +class Solution { +public: + int numOfUnplacedFruits(vector& fruits, vector& baskets) { + SegmentTree tree(baskets); + int n = baskets.size(); + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +}; ``` #### Go ```go +type SegmentTree struct { + nums, tr []int +} + +func NewSegmentTree(nums []int) *SegmentTree { + n := len(nums) + tree := &SegmentTree{ + nums: nums, + tr: make([]int, n*4), + } + tree.build(1, 1, n) + return tree +} + +func (st *SegmentTree) build(u, l, r int) { + if l == r { + st.tr[u] = st.nums[l-1] + return + } + mid := (l + r) >> 1 + st.build(u*2, l, mid) + st.build(u*2+1, mid+1, r) + st.pushup(u) +} + +func (st *SegmentTree) modify(u, l, r, i, v int) { + if l == r { + st.tr[u] = v + return + } + mid := (l + r) >> 1 + if i <= mid { + st.modify(u*2, l, mid, i, v) + } else { + st.modify(u*2+1, mid+1, r, i, v) + } + st.pushup(u) +} + +func (st *SegmentTree) query(u, l, r, v int) int { + if st.tr[u] < v { + return -1 + } + if l == r { + return l + } + mid := (l + r) >> 1 + if st.tr[u*2] >= v { + return st.query(u*2, l, mid, v) + } + return st.query(u*2+1, mid+1, r, v) +} + +func (st *SegmentTree) pushup(u int) { + st.tr[u] = max(st.tr[u*2], st.tr[u*2+1]) +} + +func numOfUnplacedFruits(fruits []int, baskets []int) (ans int) { + tree := NewSegmentTree(baskets) + n := len(baskets) + for _, x := range fruits { + i := tree.query(1, 1, n, x) + if i < 0 { + ans++ + } else { + tree.modify(1, 1, n, i, 0) + } + } + return +} +``` + +#### TypeScript + +```ts +class SegmentTree { + nums: number[]; + tr: number[]; + + constructor(nums: number[]) { + this.nums = nums; + const n = nums.length; + this.tr = Array(n * 4).fill(0); + this.build(1, 1, n); + } + + build(u: number, l: number, r: number): void { + if (l === r) { + this.tr[u] = this.nums[l - 1]; + return; + } + const mid = (l + r) >> 1; + this.build(u * 2, l, mid); + this.build(u * 2 + 1, mid + 1, r); + this.pushup(u); + } + + modify(u: number, l: number, r: number, i: number, v: number): void { + if (l === r) { + this.tr[u] = v; + return; + } + const mid = (l + r) >> 1; + if (i <= mid) { + this.modify(u * 2, l, mid, i, v); + } else { + this.modify(u * 2 + 1, mid + 1, r, i, v); + } + this.pushup(u); + } + + query(u: number, l: number, r: number, v: number): number { + if (this.tr[u] < v) { + return -1; + } + if (l === r) { + return l; + } + const mid = (l + r) >> 1; + if (this.tr[u * 2] >= v) { + return this.query(u * 2, l, mid, v); + } + return this.query(u * 2 + 1, mid + 1, r, v); + } + + pushup(u: number): void { + this.tr[u] = Math.max(this.tr[u * 2], this.tr[u * 2 + 1]); + } +} + +function numOfUnplacedFruits(fruits: number[], baskets: number[]): number { + const tree = new SegmentTree(baskets); + const n = baskets.length; + let ans = 0; + for (const x of fruits) { + const i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; +} +``` +#### Rust + +```rust +struct SegmentTree<'a> { + nums: &'a [i32], + tr: Vec, +} + +impl<'a> SegmentTree<'a> { + fn new(nums: &'a [i32]) -> Self { + let n = nums.len(); + let mut tree = SegmentTree { + nums, + tr: vec![0; n * 4], + }; + tree.build(1, 1, n); + tree + } + + fn build(&mut self, u: usize, l: usize, r: usize) { + if l == r { + self.tr[u] = self.nums[l - 1]; + return; + } + let mid = (l + r) >> 1; + self.build(u * 2, l, mid); + self.build(u * 2 + 1, mid + 1, r); + self.pushup(u); + } + + fn modify(&mut self, u: usize, l: usize, r: usize, i: usize, v: i32) { + if l == r { + self.tr[u] = v; + return; + } + let mid = (l + r) >> 1; + if i <= mid { + self.modify(u * 2, l, mid, i, v); + } else { + self.modify(u * 2 + 1, mid + 1, r, i, v); + } + self.pushup(u); + } + + fn query(&self, u: usize, l: usize, r: usize, v: i32) -> i32 { + if self.tr[u] < v { + return -1; + } + if l == r { + return l as i32; + } + let mid = (l + r) >> 1; + if self.tr[u * 2] >= v { + return self.query(u * 2, l, mid, v); + } + self.query(u * 2 + 1, mid + 1, r, v) + } + + fn pushup(&mut self, u: usize) { + self.tr[u] = self.tr[u * 2].max(self.tr[u * 2 + 1]); + } +} + +impl Solution { + pub fn num_of_unplaced_fruits(fruits: Vec, baskets: Vec) -> i32 { + let mut tree = SegmentTree::new(&baskets); + let n = baskets.len(); + let mut ans = 0; + for &x in fruits.iter() { + let i = tree.query(1, 1, n, x); + if i < 0 { + ans += 1; + } else { + tree.modify(1, 1, n, i as usize, 0); + } + } + ans + } +} ``` diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/README_EN.md b/solution/3400-3499/3479.Fruits Into Baskets III/README_EN.md index 15165f9647c17..982c82e57d515 100644 --- a/solution/3400-3499/3479.Fruits Into Baskets III/README_EN.md +++ b/solution/3400-3499/3479.Fruits Into Baskets III/README_EN.md @@ -85,32 +85,455 @@ tags: -### Solution 1 +### Solution 1: Segment Tree Binary Search + +We can use a segment tree to maintain the maximum basket capacity in an interval, which allows us to quickly find the first basket with capacity greater than or equal to the fruit quantity through binary search. If no such basket is found, we increment the answer by one; if found, we set that basket's capacity to zero, indicating that the basket has been used. + +The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$, where $n$ is the length of $\textit{baskets}$. #### Python3 ```python - +class SegmentTree: + __slots__ = ["nums", "tr"] + + def __init__(self, nums): + self.nums = nums + n = len(nums) + self.tr = [0] * (n << 2) + self.build(1, 1, n) + + def build(self, u, l, r): + if l == r: + self.tr[u] = self.nums[l - 1] + return + mid = (l + r) >> 1 + self.build(u << 1, l, mid) + self.build(u << 1 | 1, mid + 1, r) + self.pushup(u) + + def modify(self, u, l, r, i, v): + if l == r: + self.tr[u] = v + return + mid = (l + r) >> 1 + if i <= mid: + self.modify(u << 1, l, mid, i, v) + else: + self.modify(u << 1 | 1, mid + 1, r, i, v) + self.pushup(u) + + def query(self, u, l, r, v): + if self.tr[u] < v: + return -1 + if l == r: + return l + mid = (l + r) >> 1 + if self.tr[u << 1] >= v: + return self.query(u << 1, l, mid, v) + return self.query(u << 1 | 1, mid + 1, r, v) + + def pushup(self, u): + self.tr[u] = max(self.tr[u << 1], self.tr[u << 1 | 1]) + + +class Solution: + def numOfUnplacedFruits(self, fruits: List[int], baskets: List[int]) -> int: + tree = SegmentTree(baskets) + n = len(baskets) + ans = 0 + for x in fruits: + i = tree.query(1, 1, n, x) + if i < 0: + ans += 1 + else: + tree.modify(1, 1, n, i, 0) + return ans ``` #### Java ```java - +class SegmentTree { + int[] nums; + int[] tr; + + public SegmentTree(int[] nums) { + this.nums = nums; + int n = nums.length; + this.tr = new int[n << 2]; + build(1, 1, n); + } + + public void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u << 1, l, mid); + build(u << 1 | 1, mid + 1, r); + pushup(u); + } + + public void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u << 1, l, mid, i, v); + } else { + modify(u << 1 | 1, mid + 1, r, i, v); + } + pushup(u); + } + + public int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u << 1] >= v) { + return query(u << 1, l, mid, v); + } + return query(u << 1 | 1, mid + 1, r, v); + } + + public void pushup(int u) { + tr[u] = Math.max(tr[u << 1], tr[u << 1 | 1]); + } +} + +class Solution { + public int numOfUnplacedFruits(int[] fruits, int[] baskets) { + SegmentTree tree = new SegmentTree(baskets); + int n = baskets.length; + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +} ``` #### C++ ```cpp - +class SegmentTree { +public: + vector nums, tr; + + SegmentTree(vector& nums) { + this->nums = nums; + int n = nums.size(); + tr.resize(n * 4); + build(1, 1, n); + } + + void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u * 2, l, mid); + build(u * 2 + 1, mid + 1, r); + pushup(u); + } + + void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u * 2, l, mid, i, v); + } else { + modify(u * 2 + 1, mid + 1, r, i, v); + } + pushup(u); + } + + int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u * 2] >= v) { + return query(u * 2, l, mid, v); + } + return query(u * 2 + 1, mid + 1, r, v); + } + + void pushup(int u) { + tr[u] = max(tr[u * 2], tr[u * 2 + 1]); + } +}; + +class Solution { +public: + int numOfUnplacedFruits(vector& fruits, vector& baskets) { + SegmentTree tree(baskets); + int n = baskets.size(); + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +}; ``` #### Go ```go +type SegmentTree struct { + nums, tr []int +} + +func NewSegmentTree(nums []int) *SegmentTree { + n := len(nums) + tree := &SegmentTree{ + nums: nums, + tr: make([]int, n*4), + } + tree.build(1, 1, n) + return tree +} + +func (st *SegmentTree) build(u, l, r int) { + if l == r { + st.tr[u] = st.nums[l-1] + return + } + mid := (l + r) >> 1 + st.build(u*2, l, mid) + st.build(u*2+1, mid+1, r) + st.pushup(u) +} + +func (st *SegmentTree) modify(u, l, r, i, v int) { + if l == r { + st.tr[u] = v + return + } + mid := (l + r) >> 1 + if i <= mid { + st.modify(u*2, l, mid, i, v) + } else { + st.modify(u*2+1, mid+1, r, i, v) + } + st.pushup(u) +} + +func (st *SegmentTree) query(u, l, r, v int) int { + if st.tr[u] < v { + return -1 + } + if l == r { + return l + } + mid := (l + r) >> 1 + if st.tr[u*2] >= v { + return st.query(u*2, l, mid, v) + } + return st.query(u*2+1, mid+1, r, v) +} + +func (st *SegmentTree) pushup(u int) { + st.tr[u] = max(st.tr[u*2], st.tr[u*2+1]) +} + +func numOfUnplacedFruits(fruits []int, baskets []int) (ans int) { + tree := NewSegmentTree(baskets) + n := len(baskets) + for _, x := range fruits { + i := tree.query(1, 1, n, x) + if i < 0 { + ans++ + } else { + tree.modify(1, 1, n, i, 0) + } + } + return +} +``` + +#### TypeScript + +```ts +class SegmentTree { + nums: number[]; + tr: number[]; + + constructor(nums: number[]) { + this.nums = nums; + const n = nums.length; + this.tr = Array(n * 4).fill(0); + this.build(1, 1, n); + } + + build(u: number, l: number, r: number): void { + if (l === r) { + this.tr[u] = this.nums[l - 1]; + return; + } + const mid = (l + r) >> 1; + this.build(u * 2, l, mid); + this.build(u * 2 + 1, mid + 1, r); + this.pushup(u); + } + + modify(u: number, l: number, r: number, i: number, v: number): void { + if (l === r) { + this.tr[u] = v; + return; + } + const mid = (l + r) >> 1; + if (i <= mid) { + this.modify(u * 2, l, mid, i, v); + } else { + this.modify(u * 2 + 1, mid + 1, r, i, v); + } + this.pushup(u); + } + + query(u: number, l: number, r: number, v: number): number { + if (this.tr[u] < v) { + return -1; + } + if (l === r) { + return l; + } + const mid = (l + r) >> 1; + if (this.tr[u * 2] >= v) { + return this.query(u * 2, l, mid, v); + } + return this.query(u * 2 + 1, mid + 1, r, v); + } + + pushup(u: number): void { + this.tr[u] = Math.max(this.tr[u * 2], this.tr[u * 2 + 1]); + } +} + +function numOfUnplacedFruits(fruits: number[], baskets: number[]): number { + const tree = new SegmentTree(baskets); + const n = baskets.length; + let ans = 0; + for (const x of fruits) { + const i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; +} +``` +#### Rust + +```rust +struct SegmentTree<'a> { + nums: &'a [i32], + tr: Vec, +} + +impl<'a> SegmentTree<'a> { + fn new(nums: &'a [i32]) -> Self { + let n = nums.len(); + let mut tree = SegmentTree { + nums, + tr: vec![0; n * 4], + }; + tree.build(1, 1, n); + tree + } + + fn build(&mut self, u: usize, l: usize, r: usize) { + if l == r { + self.tr[u] = self.nums[l - 1]; + return; + } + let mid = (l + r) >> 1; + self.build(u * 2, l, mid); + self.build(u * 2 + 1, mid + 1, r); + self.pushup(u); + } + + fn modify(&mut self, u: usize, l: usize, r: usize, i: usize, v: i32) { + if l == r { + self.tr[u] = v; + return; + } + let mid = (l + r) >> 1; + if i <= mid { + self.modify(u * 2, l, mid, i, v); + } else { + self.modify(u * 2 + 1, mid + 1, r, i, v); + } + self.pushup(u); + } + + fn query(&self, u: usize, l: usize, r: usize, v: i32) -> i32 { + if self.tr[u] < v { + return -1; + } + if l == r { + return l as i32; + } + let mid = (l + r) >> 1; + if self.tr[u * 2] >= v { + return self.query(u * 2, l, mid, v); + } + self.query(u * 2 + 1, mid + 1, r, v) + } + + fn pushup(&mut self, u: usize) { + self.tr[u] = self.tr[u * 2].max(self.tr[u * 2 + 1]); + } +} + +impl Solution { + pub fn num_of_unplaced_fruits(fruits: Vec, baskets: Vec) -> i32 { + let mut tree = SegmentTree::new(&baskets); + let n = baskets.len(); + let mut ans = 0; + for &x in fruits.iter() { + let i = tree.query(1, 1, n, x); + if i < 0 { + ans += 1; + } else { + tree.modify(1, 1, n, i as usize, 0); + } + } + ans + } +} ``` diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.cpp b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.cpp new file mode 100644 index 0000000000000..0b32f66ae02a2 --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.cpp @@ -0,0 +1,72 @@ +class SegmentTree { +public: + vector nums, tr; + + SegmentTree(vector& nums) { + this->nums = nums; + int n = nums.size(); + tr.resize(n * 4); + build(1, 1, n); + } + + void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u * 2, l, mid); + build(u * 2 + 1, mid + 1, r); + pushup(u); + } + + void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u * 2, l, mid, i, v); + } else { + modify(u * 2 + 1, mid + 1, r, i, v); + } + pushup(u); + } + + int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u * 2] >= v) { + return query(u * 2, l, mid, v); + } + return query(u * 2 + 1, mid + 1, r, v); + } + + void pushup(int u) { + tr[u] = max(tr[u * 2], tr[u * 2 + 1]); + } +}; + +class Solution { +public: + int numOfUnplacedFruits(vector& fruits, vector& baskets) { + SegmentTree tree(baskets); + int n = baskets.size(); + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +}; diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.go b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.go new file mode 100644 index 0000000000000..9a3ac8ea39e5c --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.go @@ -0,0 +1,70 @@ +type SegmentTree struct { + nums, tr []int +} + +func NewSegmentTree(nums []int) *SegmentTree { + n := len(nums) + tree := &SegmentTree{ + nums: nums, + tr: make([]int, n*4), + } + tree.build(1, 1, n) + return tree +} + +func (st *SegmentTree) build(u, l, r int) { + if l == r { + st.tr[u] = st.nums[l-1] + return + } + mid := (l + r) >> 1 + st.build(u*2, l, mid) + st.build(u*2+1, mid+1, r) + st.pushup(u) +} + +func (st *SegmentTree) modify(u, l, r, i, v int) { + if l == r { + st.tr[u] = v + return + } + mid := (l + r) >> 1 + if i <= mid { + st.modify(u*2, l, mid, i, v) + } else { + st.modify(u*2+1, mid+1, r, i, v) + } + st.pushup(u) +} + +func (st *SegmentTree) query(u, l, r, v int) int { + if st.tr[u] < v { + return -1 + } + if l == r { + return l + } + mid := (l + r) >> 1 + if st.tr[u*2] >= v { + return st.query(u*2, l, mid, v) + } + return st.query(u*2+1, mid+1, r, v) +} + +func (st *SegmentTree) pushup(u int) { + st.tr[u] = max(st.tr[u*2], st.tr[u*2+1]) +} + +func numOfUnplacedFruits(fruits []int, baskets []int) (ans int) { + tree := NewSegmentTree(baskets) + n := len(baskets) + for _, x := range fruits { + i := tree.query(1, 1, n, x) + if i < 0 { + ans++ + } else { + tree.modify(1, 1, n, i, 0) + } + } + return +} diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.java b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.java new file mode 100644 index 0000000000000..4d4403cb04b08 --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.java @@ -0,0 +1,71 @@ +class SegmentTree { + int[] nums; + int[] tr; + + public SegmentTree(int[] nums) { + this.nums = nums; + int n = nums.length; + this.tr = new int[n << 2]; + build(1, 1, n); + } + + public void build(int u, int l, int r) { + if (l == r) { + tr[u] = nums[l - 1]; + return; + } + int mid = (l + r) >> 1; + build(u << 1, l, mid); + build(u << 1 | 1, mid + 1, r); + pushup(u); + } + + public void modify(int u, int l, int r, int i, int v) { + if (l == r) { + tr[u] = v; + return; + } + int mid = (l + r) >> 1; + if (i <= mid) { + modify(u << 1, l, mid, i, v); + } else { + modify(u << 1 | 1, mid + 1, r, i, v); + } + pushup(u); + } + + public int query(int u, int l, int r, int v) { + if (tr[u] < v) { + return -1; + } + if (l == r) { + return l; + } + int mid = (l + r) >> 1; + if (tr[u << 1] >= v) { + return query(u << 1, l, mid, v); + } + return query(u << 1 | 1, mid + 1, r, v); + } + + public void pushup(int u) { + tr[u] = Math.max(tr[u << 1], tr[u << 1 | 1]); + } +} + +class Solution { + public int numOfUnplacedFruits(int[] fruits, int[] baskets) { + SegmentTree tree = new SegmentTree(baskets); + int n = baskets.length; + int ans = 0; + for (int x : fruits) { + int i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; + } +} diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.py b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.py new file mode 100644 index 0000000000000..04b5f654c09fa --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.py @@ -0,0 +1,55 @@ +class SegmentTree: + __slots__ = ["nums", "tr"] + + def __init__(self, nums): + self.nums = nums + n = len(nums) + self.tr = [0] * (n << 2) + self.build(1, 1, n) + + def build(self, u, l, r): + if l == r: + self.tr[u] = self.nums[l - 1] + return + mid = (l + r) >> 1 + self.build(u << 1, l, mid) + self.build(u << 1 | 1, mid + 1, r) + self.pushup(u) + + def modify(self, u, l, r, i, v): + if l == r: + self.tr[u] = v + return + mid = (l + r) >> 1 + if i <= mid: + self.modify(u << 1, l, mid, i, v) + else: + self.modify(u << 1 | 1, mid + 1, r, i, v) + self.pushup(u) + + def query(self, u, l, r, v): + if self.tr[u] < v: + return -1 + if l == r: + return l + mid = (l + r) >> 1 + if self.tr[u << 1] >= v: + return self.query(u << 1, l, mid, v) + return self.query(u << 1 | 1, mid + 1, r, v) + + def pushup(self, u): + self.tr[u] = max(self.tr[u << 1], self.tr[u << 1 | 1]) + + +class Solution: + def numOfUnplacedFruits(self, fruits: List[int], baskets: List[int]) -> int: + tree = SegmentTree(baskets) + n = len(baskets) + ans = 0 + for x in fruits: + i = tree.query(1, 1, n, x) + if i < 0: + ans += 1 + else: + tree.modify(1, 1, n, i, 0) + return ans diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.rs b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.rs new file mode 100644 index 0000000000000..a9f530bdb0c84 --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.rs @@ -0,0 +1,76 @@ +struct SegmentTree<'a> { + nums: &'a [i32], + tr: Vec, +} + +impl<'a> SegmentTree<'a> { + fn new(nums: &'a [i32]) -> Self { + let n = nums.len(); + let mut tree = SegmentTree { + nums, + tr: vec![0; n * 4], + }; + tree.build(1, 1, n); + tree + } + + fn build(&mut self, u: usize, l: usize, r: usize) { + if l == r { + self.tr[u] = self.nums[l - 1]; + return; + } + let mid = (l + r) >> 1; + self.build(u * 2, l, mid); + self.build(u * 2 + 1, mid + 1, r); + self.pushup(u); + } + + fn modify(&mut self, u: usize, l: usize, r: usize, i: usize, v: i32) { + if l == r { + self.tr[u] = v; + return; + } + let mid = (l + r) >> 1; + if i <= mid { + self.modify(u * 2, l, mid, i, v); + } else { + self.modify(u * 2 + 1, mid + 1, r, i, v); + } + self.pushup(u); + } + + fn query(&self, u: usize, l: usize, r: usize, v: i32) -> i32 { + if self.tr[u] < v { + return -1; + } + if l == r { + return l as i32; + } + let mid = (l + r) >> 1; + if self.tr[u * 2] >= v { + return self.query(u * 2, l, mid, v); + } + self.query(u * 2 + 1, mid + 1, r, v) + } + + fn pushup(&mut self, u: usize) { + self.tr[u] = self.tr[u * 2].max(self.tr[u * 2 + 1]); + } +} + +impl Solution { + pub fn num_of_unplaced_fruits(fruits: Vec, baskets: Vec) -> i32 { + let mut tree = SegmentTree::new(&baskets); + let n = baskets.len(); + let mut ans = 0; + for &x in fruits.iter() { + let i = tree.query(1, 1, n, x); + if i < 0 { + ans += 1; + } else { + tree.modify(1, 1, n, i as usize, 0); + } + } + ans + } +} diff --git a/solution/3400-3499/3479.Fruits Into Baskets III/Solution.ts b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.ts new file mode 100644 index 0000000000000..427580f6f7025 --- /dev/null +++ b/solution/3400-3499/3479.Fruits Into Baskets III/Solution.ts @@ -0,0 +1,69 @@ +class SegmentTree { + nums: number[]; + tr: number[]; + + constructor(nums: number[]) { + this.nums = nums; + const n = nums.length; + this.tr = Array(n * 4).fill(0); + this.build(1, 1, n); + } + + build(u: number, l: number, r: number): void { + if (l === r) { + this.tr[u] = this.nums[l - 1]; + return; + } + const mid = (l + r) >> 1; + this.build(u * 2, l, mid); + this.build(u * 2 + 1, mid + 1, r); + this.pushup(u); + } + + modify(u: number, l: number, r: number, i: number, v: number): void { + if (l === r) { + this.tr[u] = v; + return; + } + const mid = (l + r) >> 1; + if (i <= mid) { + this.modify(u * 2, l, mid, i, v); + } else { + this.modify(u * 2 + 1, mid + 1, r, i, v); + } + this.pushup(u); + } + + query(u: number, l: number, r: number, v: number): number { + if (this.tr[u] < v) { + return -1; + } + if (l === r) { + return l; + } + const mid = (l + r) >> 1; + if (this.tr[u * 2] >= v) { + return this.query(u * 2, l, mid, v); + } + return this.query(u * 2 + 1, mid + 1, r, v); + } + + pushup(u: number): void { + this.tr[u] = Math.max(this.tr[u * 2], this.tr[u * 2 + 1]); + } +} + +function numOfUnplacedFruits(fruits: number[], baskets: number[]): number { + const tree = new SegmentTree(baskets); + const n = baskets.length; + let ans = 0; + for (const x of fruits) { + const i = tree.query(1, 1, n, x); + if (i < 0) { + ans++; + } else { + tree.modify(1, 1, n, i, 0); + } + } + return ans; +}