feat: add solutions to lc problem: No.3479 (#4621)

No.3479.Fruits Into Baskets III

Author: yanglbme

solution/3400-3499/3479.Fruits Into Baskets III/README.md

@@ -0,0 +1,72 @@
+class SegmentTree {
+public:
+    vector<int> nums, tr;
+
+    SegmentTree(vector<int>& 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<int>& fruits, vector<int>& 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;
+    }
+};

solution/3400-3499/3479.Fruits Into Baskets III/README_EN.md

@@ -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
+}

solution/3400-3499/3479.Fruits Into Baskets III/Solution.cpp

@@ -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;
+    }
+}

solution/3400-3499/3479.Fruits Into Baskets III/Solution.go

@@ -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

solution/3400-3499/3479.Fruits Into Baskets III/Solution.java

@@ -0,0 +1,76 @@
+struct SegmentTree<'a> {
+    nums: &'a [i32],
+    tr: Vec<i32>,
+}
+
+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<i32>, baskets: Vec<i32>) -> 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
+    }
+}