thảo luận Leetcode mỗi ngày

use std::collections::BTreeMap;

struct MyCalendarTwo {
    entry_exit: BTreeMap<i32, i32>
}

impl MyCalendarTwo {

    fn new() -> Self {
        Self {
            entry_exit: BTreeMap::new()
        }
    }

    fn book(&mut self, start: i32, end: i32) -> bool {
        self.entry_exit.entry(start).
            and_modify(|freq_delta| *freq_delta += 1).or_insert(1);

        self.entry_exit.entry(end).
            and_modify(|freq_delta| *freq_delta -= 1).or_insert(-1);

        let (mut max_count, mut count) = (0, 0);

        for (&point, &delta) in self.entry_exit.iter() {
            count += delta;
            max_count = max_count.max(count);

            if max_count > 2 {
                self.entry_exit.entry(start).
                    and_modify(|freq_delta| *freq_delta -= 1);

                self.entry_exit.entry(end).
                    and_modify(|freq_delta| *freq_delta += 1);

                return false;
            }
        }

        true
    }
}

struct MyCalendarTwo {
    once: Vec<(i32, i32)>,
    twice: Vec<(i32, i32)>
}

impl MyCalendarTwo {
    fn new() -> Self {
        Self {
            once: vec![],
            twice: vec![]
        }
    }

    fn book(&mut self, start: i32, end: i32) -> bool {
        for (other_start, other_end) in self.twice.iter().copied() {
            if other_start.max(start) < other_end.min(end) {
                return false;
            }
        }

        // find intersections of overlapping intervals
        for (other_start, other_end) in self.once.iter().copied() {
            let new_start = other_start.max(start);
            let new_end = other_end.min(end);

            if new_start < new_end {
                self.twice.push((new_start, new_end));
            }
        }

        self.once.push((start, end));

        true
    }
}

use std::collections::BTreeMap;

use std::iter::{FromIterator, once};

struct MyCalendarThree {
    data: BTreeMap<i32, i32>,
    max: i32
}

impl MyCalendarThree {
    fn new() -> Self {
        MyCalendarThree {
            // BTreeMap with one key-value pair (0, 0) at the start
            data: BTreeMap::from_iter(once((0, 0))),
            max: 0i32,
        }
    }

    fn book(&mut self, start: i32, end: i32) -> i32 {
        // find the value of the closest key that is smaller than `start`
        // sentinel key-value pair (0, 0) ensures that this call will always be successful
        let (_, &(mut current)) =
            self.data.range(..=start).next_back().unwrap();

        // insert if not present
        self.data.entry(start).or_insert(current);

        // iterate over all ranges with their starts falling within the half-open interval `[start, end)`
        for (_, count) in self.data.range_mut(start..end) {
            current = *count;
            *count += 1;

            self.max = self.max.max(current + 1);
        }

        // insert if not present
        self.data.entry(end).or_insert(current);

        self.max
    }
}

struct MyCalendarTwo {
    time: std::collections::BTreeMap<i32, i32>,
}

impl MyCalendarTwo {
    fn new() -> Self {
        Self { time: Default::default() }   
    }
    
    fn book(&mut self, start: i32, end: i32) -> bool {
        self.time.entry(start).and_modify(|t| *t += 1).or_insert(1);
        self.time.entry(end).and_modify(|t| *t -= 1).or_insert(-1);

        let mut count = 0;
        for &t in self.time.values() {
            count += t;
            if count >= 3 {
                self.time.entry(start).and_modify(|t| *t -= 1);
                self.time.entry(end).and_modify(|t| *t += 1);
                return false;
            }
        }

        true
    }
}