391&699

Author: caibirdme

src/lib.rs

@@ -209,6 +209,7 @@ mod prob_385;
 mod prob_386;
 mod prob_388;
 mod prob_390;
+mod prob_391;
 mod prob_393;
 mod prob_394;
 mod prob_395;
@@ -293,6 +294,7 @@ mod prob_684;
 mod prob_685;
 mod prob_686;
 mod prob_698;
+mod prob_699;
 mod prob_713;
 mod prob_718;
 mod prob_732;

src/prob_391.rs

@@ -0,0 +1,78 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn is_rectangle_cover(rectangles: Vec<Vec<i32>>) -> bool {
+        let mut set = HashSet::new();
+        let mut lx = std::i32::MAX;
+        let mut ly = std::i32::MAX;
+        let mut rx = std::i32::MIN;
+        let mut ry = std::i32::MIN;
+        let mut area = 0;
+        for rec in rectangles {
+            let (x1,y1,x2,y2) = (rec[0], rec[1], rec[2], rec[3]);
+            area += (x2-x1)*(y2-y1);
+            lx = lx.min(x1);
+            ly = ly.min(y1);
+            rx = rx.max(x2);
+            ry = ry.max(y2);
+            if !set.contains(&(x1, y1)) {
+                set.insert((x1,y1));
+            } else {
+                set.remove(&(x1, y1));
+            }
+            if !set.contains(&(x2,y2)) {
+                set.insert((x2, y2));
+            } else {
+                set.remove(&(x2, y2));
+            }
+            if !set.contains(&(x1,y2)) {
+                set.insert((x1, y2));
+            } else {
+                set.remove(&(x1, y2));
+            }
+            if !set.contains(&(x2,y1)) {
+                set.insert((x2, y1));
+            } else {
+                set.remove(&(x2, y1));
+            }
+        }
+        if set.len() != 4 ||
+            !set.contains(&(lx, ly)) ||
+            !set.contains(&(rx, ry)) ||
+            !set.contains(&(lx, ry)) ||
+            !set.contains(&(rx, ly))
+        {
+            return false;
+        }
+        area == (rx-lx)*(ry-ly)
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_is_rectangle_cover() {
+        let test_cases = vec![
+            (vec![
+                vec![0,0,1,1],
+                vec![0,0,2,1],
+                vec![1,0,2,1],
+                vec![0,2,2,3],
+            ], false),
+            (vec![
+                vec![1,1,3,3],
+                vec![3,1,4,2],
+                vec![3,2,4,4],
+                vec![1,3,2,4],
+                vec![2,3,3,4],
+            ], true),
+        ];
+        for (rectangles, ok) in test_cases {
+            assert_eq!(Solution::is_rectangle_cover(rectangles.clone()), ok, "rectangles: {:?}", rectangles);
+        }
+    }
+}

src/prob_699.rs

@@ -0,0 +1,135 @@
+use std::collections::{BTreeSet, HashMap};
+use std::cmp::max;
+
+struct SegmentTree {
+    lch: Option<Box<SegmentTree>>,
+    rch: Option<Box<SegmentTree>>,
+    val: i32,
+    delta: i32,
+}
+
+impl SegmentTree {
+    fn new(n: usize) -> Self {
+        *Self::cons(1, n).unwrap()
+    }
+    fn new_leaf() -> Option<Box<SegmentTree>> {
+        Some(Box::new(SegmentTree{
+            lch: None,
+            rch: None,
+            val:0,
+            delta:0,
+        }))
+    }
+    fn cons(l: usize, r: usize) -> Option<Box<SegmentTree>> {
+        if l == r {
+            return Self::new_leaf();
+        }
+        let m = (l+r)/2;
+        Some(Box::new(SegmentTree{
+            lch: Self::cons(l, m),
+            rch: Self::cons(m+1, r),
+            val: 0,
+            delta: 0,
+        }))
+    }
+    fn search(&self, l: usize, r: usize, left: usize, right: usize) -> i32 {
+        if l == left && r == right {
+            if self.delta > 0 {
+                return self.delta;
+            }
+            return self.val;
+        }
+        if self.delta > 0 {
+            return self.delta;
+        }
+        let m = (l+r)/2;
+        if right <= m {
+            self.lch.as_ref().unwrap().search(l, m, left, right)
+        } else if left > m {
+            self.rch.as_ref().unwrap().search(m+1, r, left, right)
+        } else {
+            max(
+                self.lch.as_ref().unwrap().search(l, m, left, m),
+                self.rch.as_ref().unwrap().search(m+1, r, m+1, right),
+            )
+        }
+    }
+    fn update(&mut self, l: usize, r: usize, left: usize, right: usize, h: i32) -> i32 {
+        if l == left && r == right {
+            if l == r {
+                self.val = h;
+            } else {
+                self.delta = h;
+            }
+            return h;
+        }
+        let m = (l+r)/2;
+        if self.delta > 0 {
+            self.lch.as_mut().unwrap().update(l, m, l, m, self.delta);
+            self.rch.as_mut().unwrap().update(m+1, r, m+1, r, self.delta);
+            self.delta = 0;
+        }
+        if right <= m {
+            let lmax = self.lch.as_mut().unwrap().update(l, m, left, right, h);
+            self.val = self.val.max(lmax);
+        } else if left > m {
+            let rmax = self.rch.as_mut().unwrap().update(m+1, r, left, right, h);
+            self.val = self.val.max(rmax);
+        } else {
+            let lmax = self.lch.as_mut().unwrap().update(l, m, left, m, h);
+            let rmax = self.rch.as_mut().unwrap().update(m+1, r, m+1, right, h);
+            self.val = max(lmax, rmax);
+        }
+        self.val
+    }
+}
+
+impl Solution {
+    pub fn falling_squares(positions: Vec<Vec<i32>>) -> Vec<i32> {
+        let mut bs = BTreeSet::new();
+        for pos in &positions {
+            let (x, l) = (pos[0], pos[1]);
+            bs.insert(x);
+            bs.insert(x+l-1);
+        }
+        let mut hash = HashMap::new();
+        for (i,&v) in bs.iter().enumerate() {
+            hash.insert(v, i+1);
+        }
+        let n = bs.len();
+        let mut sgt = SegmentTree::new(n);
+        positions.into_iter().map(|pos| {
+            let (x, l) = (pos[0], pos[1]);
+            let mx = *hash.get(&x).unwrap();
+            let my = *hash.get(&(x+l-1)).unwrap();
+            let t = sgt.search(1, n, mx, my);
+            let v = sgt.update(1, n, mx, my, l+t);
+            v
+        }).collect()
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_falling_squares() {
+        let test_cases = vec![
+            (vec![
+                vec![9,7],vec![1,9],vec![3,1], vec![1,1],vec![2,2], vec![100,15], vec![15, 13],
+            ], vec![7, 16, 17, 17, 19, 19, 20]),
+            (vec![
+                vec![100, 100], vec![200, 100], vec![199, 2],
+            ], vec![100, 100, 102]),
+            (vec![
+                vec![1,2],vec![2,3],vec![6,1],
+            ], vec![2,5,5]),
+        ];
+        for (positions, expect) in test_cases {
+            assert_eq!(Solution::falling_squares(positions.clone()), expect, "positions: {:?}", positions);
+        }
+    }
+}