Solution 1: Range sum query

Assuming we can collect fruits in range [l, r], we need a fast query to compute the sum of those fruits.

Given startPos and k, we have four options:
1. move i steps to the left
2. move i steps to the left and k – i steps to the right.
3. move i steps to the right
4. move i steps to the right and k – i steps to the left.

We enumerate i steps and calculate maximum range [l, r] covered by each option, and collect all the fruit in that range.

Time complexity: O(m + k)
Space complexity: O(m)
where m = max(max(pos), startPos)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    const int m = max(startPos, (*max_element(begin(fruits), end(fruits)))[0]);
    vector<int> sums(m + 2);   
    for (int i = 0, j = 0; i <= m; ++i) {
      sums[i + 1] += sums[i];
      while (j < fruits.size() && fruits[j][0] == i)        
        sums[i + 1] += fruits[j++][1];      
    }    
    int ans = 0;
    for (int s = 0; s <= k; ++s) {
      if (startPos - s >= 0) {
        int l = startPos - s;
        int r = min(max(startPos, l + (k - s)), m);        
        ans = max(ans, sums[r + 1] - sums[l]);
      }
      if (startPos + s <= m) {
        int r = startPos + s;
        int l = max(0, min(startPos, r - (k - s)));
        ans = max(ans, sums[r + 1] - sums[l]);
      }
    }             
    return ans;
  }
};

Solution 2: Sliding Window

Maintain a window [l, r] such that the steps to cover [l, r] from startPos is less or equal to k.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    auto steps = [&](int l, int r) {
      if (r <= startPos)
        return startPos - l;
      else if (l >= startPos)
        return r - startPos;
      else
        return min(startPos + r - 2 * l, 2 * r - startPos - l);
    };
    int ans = 0;
    for (int r = 0, l = 0, cur = 0; r < fruits.size(); ++r) {
      cur += fruits[r][1];
      while (l <= r && steps(fruits[l][0], fruits[r][0]) > k)
        cur -= fruits[l++][1];      
      ans = max(ans, cur);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2106. Maximum Fruits Harvested After at Most K Steps appeared first on Huahua's Tech Road.

Return true if each integer in the inclusive range [left, right] is covered by at least one interval in ranges. Return false otherwise.

An integer x is covered by an interval ranges[i] = [starti, endi] if starti <= x <= endi.

Example 1:

Input: ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5
Output: true
Explanation: Every integer between 2 and 5 is covered:
- 2 is covered by the first range.
- 3 and 4 are covered by the second range.
- 5 is covered by the third range.

Example 2:

Input: ranges = [[1,10],[10,20]], left = 21, right = 21
Output: false
Explanation: 21 is not covered by any range.

Constraints:

• 1 <= ranges.length <= 50
• 1 <= starti <= endi <= 50
• 1 <= left <= right <= 50

Solution 1: Hashtable

Time complexity: O(n * (right – left))
Space complexity: O(right – left)

// Author: Huahua
class Solution {
public:  
  bool isCovered(vector<vector<int>>& ranges, int left, int right) {
    unordered_set<int> s;
    for (const auto& range : ranges)
      for (int i = max(left, range[0]); i <= min(right, range[1]); ++i)
        s.insert(i);    
    return s.size() == right - left + 1;
  }
};

The post 花花酱 LeetCode 1893. Check if All the Integers in a Range Are Covered appeared first on Huahua's Tech Road.

You can only attend one event at a time. If you choose to attend an event, you must attend the entire event. Note that the end day is inclusive: that is, you cannot attend two events where one of them starts and the other ends on the same day.

Return the maximum sum of values that you can receive by attending events.

Example 1:

Input: events = [[1,2,4],[3,4,3],[2,3,1]], k = 2
Output: 7
Explanation: Choose the green events, 0 and 1 (0-indexed) for a total value of 4 + 3 = 7.

Example 2:

Input: events = [[1,2,4],[3,4,3],[2,3,10]], k = 2
Output: 10
Explanation: Choose event 2 for a total value of 10.
Notice that you cannot attend any other event as they overlap, and that you do not have to attend k events.

Example 3:

Input: events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3
Output: 9
Explanation: Although the events do not overlap, you can only attend 3 events. Pick the highest valued three.

Constraints:

• 1 <= k <= events.length
• 1 <= k * events.length <= 106
• 1 <= startDayi <= endDayi <= 109
• 1 <= valuei <= 106

Solution: DP + Binary Search

Sort events by ending time.
dp[i][j] := max value we can get by attending at most j events among events[0~i].
dp[i][j] = max(dp[i – 1][j], dp[p][j – 1] + value[i])
p is the first event that does not overlap with the current one.

Time complexity: O(nlogn + nk)
Space complexity: O(nk)

// Author: Huahua
class Solution {
public:
  int maxValue(vector<vector<int>>& events, int k) {
    const int n = events.size(); 
    vector<vector<int>> dp(n + 1, vector<int>(k + 1));    
    vector<int> e(n);
    auto comp = [](const vector<int>& a, const vector<int>& b) {
      return a[1] < b[1];
    };
    
    sort(begin(events), end(events), comp);
    
    for (int i = 1; i <= n; ++i) {
      const int p = lower_bound(begin(events), 
                                begin(events) + i, 
                                vector<int>{0, events[i - 1][0], 0},
                                comp) - begin(events);
      for (int j = 1; j <= k; ++j)
        dp[i][j] = max(dp[i - 1][j], 
                       dp[p][j - 1] + events[i - 1][2]);
    }    
    return dp[n][k];
  }
};

The post 花花酱 LeetCode 1751. Maximum Number of Events That Can Be Attended II appeared first on Huahua's Tech Road.

There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue.

In each round of the game, Alice divides the row into two non-empty rows (i.e. left row and right row), then Bob calculates the value of each row which is the sum of the values of all the stones in this row. Bob throws away the row which has the maximum value, and Alice’s score increases by the value of the remaining row. If the value of the two rows are equal, Bob lets Alice decide which row will be thrown away. The next round starts with the remaining row.

The game ends when there is only one stone remaining. Alice’s is initially zero.

Return the maximum score that Alice can obtain.

Example 1:

Input: stoneValue = [6,2,3,4,5,5]
Output: 18
Explanation: In the first round, Alice divides the row to [6,2,3], [4,5,5]. The left row has the value 11 and the right row has value 14. Bob throws away the right row and Alice's score is now 11.
In the second round Alice divides the row to [6], [2,3]. This time Bob throws away the left row and Alice's score becomes 16 (11 + 5).
The last round Alice has only one choice to divide the row which is [2], [3]. Bob throws away the right row and Alice's score is now 18 (16 + 2). The game ends because only one stone is remaining in the row.

Example 2:

Input: stoneValue = [7,7,7,7,7,7,7]
Output: 28

Example 3:

Input: stoneValue = [4]
Output: 0

Constraints:

• 1 <= stoneValue.length <= 500
• 1 <= stoneValue[i] <= 10^6

Solution: Range DP + Prefix Sum

dp[l][r] := max store Alice can get from range [l, r]
sum_l = sum(l, k), sum_r = sum(k + 1, r)
dp[l][r] = max{
dp[l][k] + sum_l if sum_l < sum_r
dp[k+1][r] + sum_r if sum_r < sum_l
max(dp[l][k], dp[k+1][r])) + sum_l if sum_l == sum_r)
} for k in [l, r)

Time complexity: O(n^3)
Space complexity: O(n^2)

class Solution {
public:
  int stoneGameV(vector<int>& stoneValue) {
    const int n = stoneValue.size();
    vector<int> sums(n + 1);
    for (int i = 0; i < n; ++i)
      sums[i + 1] = sums[i] + stoneValue[i];
    vector<vector<int>> cache(n, vector<int>(n, -1));
    // max value alice can get from range [l, r]
    function<int(int, int)> dp = [&](int l, int r) {
      if (l == r) return 0;
      int& ans = cache[l][r];
      if (ans != -1) return ans;
      for (int k = l; k < r; ++k) {
        // left: [l, k], right: [k + 1, r]
        int sum_l = sums[k + 1] - sums[l];
        int sum_r = sums[r + 1] - sums[k + 1];
        if (sum_l > sum_r)
          ans = max(ans, sum_r + dp(k + 1, r));
        else if (sum_l < sum_r)
          ans = max(ans, sum_l + dp(l, k));
        else
          ans = max(ans, sum_l + max(dp(l, k), dp(k + 1, r)));
      }      
      return ans;
    };
    
    return dp(0, n - 1);
  }
};

The post 花花酱 LeetCode 1563. Stone Game V appeared first on Huahua's Tech Road.

Given the root node of a binary search tree, return the sum of values of all nodes with value between L and R (inclusive).

The binary search tree is guaranteed to have unique values.

Example 1:

Input: root = [10,5,15,3,7,null,18], L = 7, R = 15
Output: 32

Example 2:

Input: root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10
Output: 23

Note:

1. The number of nodes in the tree is at most 10000.
2. The final answer is guaranteed to be less than 2^31.

Solution: In-order traversal

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua, running time: 72 ms
class Solution {
public:
  int rangeSumBST(TreeNode* root, int L, int R) {
    if (!root) return 0;
    int sum = 0;
    if (root->val >= L) sum += rangeSumBST(root->left, L, R);
    if (root->val >= L && root->val <= R) sum += root->val;
    if (root->val <= R) sum += rangeSumBST(root->right, L, R);
    return sum;
  }
};

The post 花花酱 LeetCode 938. Range Sum of BST appeared first on Huahua's Tech Road.

Given an array A of integers, for each integer A[i] we need to choose either x = -K or x = K, and add x to A[i] (only once).

After this process, we have some array B.

Return the smallest possible difference between the maximum value of B and the minimum value of B.

Example 1:

Input: A = [1], K = 0
Output: 0
Explanation: B = [1]

Example 2:

Input: A = [0,10], K = 2
Output: 6
Explanation: B = [2,8]

Example 3:

Input: A = [1,3,6], K = 3
Output: 3
Explanation: B = [4,6,3]

Note:

1. 1 <= A.length <= 10000
2. 0 <= A[i] <= 10000
3. 0 <= K <= 10000

Solution: Greedy

Sort the array and compare adjacent numbers.

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int smallestRangeII(vector<int>& A, int K) {    
    sort(begin(A), end(A));    
    int ans = A.back() - A.front();
    for (int i = 1; i < A.size(); ++i) {      
      int l = min(A.front() + K, A[i] - K);
      int h = max(A.back() - K, A[i - 1] + K);
      ans = min(ans, h - l);
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def smallestRangeII(self, A, K):
    A.sort()
    ans = A[-1] - A[0]
    for a, b in zip(A[0:-1], A[1:]):
      l = min(A[0] + K, b - K)
      h = max(A[-1] - K, a + K)
      ans = min(ans, h - l)
    return ans

The post 花花酱 LeetCode 910. Smallest Range II appeared first on Huahua's Tech Road.

Given an array A of integers, for each integer A[i] we may choose any x with -K <= x <= K, and add xto A[i].

After this process, we have some array B.

Return the smallest possible difference between the maximum value of B and the minimum value of B.

Input: A = [1], K = 0
Output: 0
Explanation: B = [1]

Input: A = [0,10], K = 2
Output: 6
Explanation: B = [2,8]

Input: A = [1,3,6], K = 3
Output: 0
Explanation: B = [3,3,3] or B = [4,4,4]

// Author: Huahua
class Solution {
public:
  int smallestRangeI(vector<int>& A, int K) {
    int a_min = *min_element(begin(A), end(A));
    int a_max = *max_element(begin(A), end(A));
    return max(0, (a_max - a_min) - 2 * K);
  }
};

# Author: Huahua, 72 ms
class Solution:
  def smallestRangeI(self, A, K):
    return max(0, max(A) - min(A) - 2 * K);

The post 花花酱 LeetCode 908. Smallest Range I appeared first on Huahua's Tech Road.

https://leetcode.com/problems/range-addition-ii/description/

Given an m * n matrix M initialized with all 0‘s and several update operations.

Operations are represented by a 2D array, and each operation is represented by an array with two positiveintegers a and b, which means M[i][j] should be added by one for all 0 <= i < a and 0 <= j < b.

You need to count and return the number of maximum integers in the matrix after performing all the operations.

Example 1:

Input: 
m = 3, n = 3
operations = [[2,2],[3,3]]
Output: 4
Explanation: 
Initially, M = 
[[0, 0, 0],
 [0, 0, 0],
 [0, 0, 0]]

After performing [2,2], M = 
[[1, 1, 0],
 [1, 1, 0],
 [0, 0, 0]]

After performing [3,3], M = 
[[2, 2, 1],
 [2, 2, 1],
 [1, 1, 1]]

So the maximum integer in M is 2, and there are four of it in M. So return 4.

Note:

1. The range of m and n is [1,40000].
2. The range of a is [1,m], and the range of b is [1,n].
3. The range of operations size won’t exceed 10,000.

Solution:

Time Complexity: O(n)

Space Complexity: O(1)

C++

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
  int maxCount(int m, int n, vector<vector<int>>& ops) {
    for (const auto& range : ops) {
      m = min(m, range[0]);
      n = min(n, range[1]);
    }
    return m * n;
  }
};

The post 花花酱 LeetCode 598. Range Addition II appeared first on Huahua's Tech Road.

Problem:

link: https://leetcode.com/problems/my-calendar-iii/description/

Implement a MyCalendarThree class to store your events. A new event can always be added.

Your class will have one method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A K-booking happens when K events have some non-empty intersection (ie., there is some time that is common to all K events.)

For each call to the method MyCalendar.book, return an integer K representing the largest integer such that there exists a K-booking in the calendar.

Your class will be called like this: MyCalendarThree cal = new MyCalendarThree();MyCalendarThree.book(start, end)

Example 1:

MyCalendarThree();
MyCalendarThree.book(10, 20); // returns 1
MyCalendarThree.book(50, 60); // returns 1
MyCalendarThree.book(10, 40); // returns 2
MyCalendarThree.book(5, 15); // returns 3
MyCalendarThree.book(5, 10); // returns 3
MyCalendarThree.book(25, 55); // returns 3
Explanation: 
The first two events can be booked and are disjoint, so the maximum K-booking is a 1-booking.
The third event [10, 40) intersects the first event, and the maximum K-booking is a 2-booking.
The remaining events cause the maximum K-booking to be only a 3-booking.
Note that the last event locally causes a 2-booking, but the answer is still 3 because
eg. [10, 20), [10, 40), and [5, 15) are still triple booked.

Note:

• The number of calls to MyCalendarThree.book per test case will be at most 400.
• In calls to MyCalendarThree.book(start, end), start and end are integers in the range [0, 10^9].

Idea:

Similar to LeetCode 731 My Calendar II Use an ordered / tree map to track the number of event at current time.

For a new book event, increase the number of events at start, decrease the number of events at end.

Scan the timeline to find the maximum number of events.

Solution 1: Count Boundaries

Time complexity: O(n^2)

Space complexity: O(n)

// Author: Huahua
// Runtime: 116 ms
class MyCalendarThree {
public:
    MyCalendarThree() {}
    
    int book(int start, int end) {
        ++deltas_[start];
        --deltas_[end];
        int ans = 0;
        int curr = 0;
        for (const auto& kv : deltas_)            
            ans = max(ans, curr += kv.second);
        return ans;
    }
private:
    map<int, int> deltas_;
};

Solution 2

// Author: Huahua
// Runtime: 66 ms
class MyCalendarThree {
public:
    MyCalendarThree() {
        counts_[INT_MIN] = 0;
        counts_[INT_MAX] = 0;
        max_count_ = 0;
    }
    
    int book(int start, int end) {        
        auto l = prev(counts_.upper_bound(start));   // l->first < start
        auto r = counts_.lower_bound(end);           // r->first >= end
        for (auto curr = l, next = curr; curr != r; curr = next) {
            ++next;
            
            if (next->first > end)
                counts_[end] = curr->second;
            
            if (curr->first <= start && next->first > start)
                max_count_ = max(max_count_, counts_[start] = curr->second + 1);            
            else
                max_count_ = max(max_count_, ++curr->second);
        }
        
        return max_count_;
    }
private:
    map<int, int> counts_;
    int max_count_;
};

Solution 3: Segment Tree

// Author: Huahua
// Runtime: 63 ms (<95.65%)
class MyCalendarThree {
public:
    MyCalendarThree(): max_count_(0) {
        root_.reset(new Node(0, 100000000, 0));        
    }
    
    int book(int start, int end) {
        Add(start, end, root_.get());
        return max_count_;
    }
private:
    struct Node {
        Node(int l, int r, int count):l(l), m(-1), r(r), count(count){}
        int l;
        int m;
        int r;
        int count;
        std::unique_ptr<Node> left;
        std::unique_ptr<Node> right;
    };
    
    void Add(int start, int end, Node* root) {
        if (root->m != -1) {
            if (end <= root->m) 
                Add(start, end, root->left.get());
            else if(start >= root->m)
                Add(start, end, root->right.get());
            else {
                Add(start, root->m, root->left.get());
                Add(root->m, end, root->right.get());
            }
            return;
        }
        
        if (start == root->l && end == root->r)
            max_count_ = max(max_count_, ++root->count);
        else if (start == root->l) {
            root->m = end;
            root->left.reset(new Node(start, root->m, root->count + 1));
            root->right.reset(new Node(root->m, root->r, root->count));
            max_count_ = max(max_count_, root->count + 1);
        } else if(end == root->r) {
            root->m = start;
            root->left.reset(new Node(root->l, root->m, root->count));
            root->right.reset(new Node(root->m, root->r, root->count + 1));
            max_count_ = max(max_count_, root->count + 1);
        } else {
            root->m = start;
            root->left.reset(new Node(root->l, root->m, root->count));
            root->right.reset(new Node(root->m, root->r, root->count));
            Add(start, end, root->right.get());
        }
    }
    
    std::unique_ptr<Node> root_;
    int max_count_;
};

"""
Author: Huahua
Runtime: 436 ms (<88.88%)
"""
class Node:
    def __init__(self, l, r, count):
        self.l = l
        self.m = -1
        self.r = r            
        self.count = count
        self.left = None
        self.right = None
            
class MyCalendarThree:        
    def __init__(self):
        self.root = Node(0, 10**9, 0)
        self.max = 0

    def book(self, start, end):
        self.add(start, end, self.root)
        return self.max
    
    def add(self, start, end, root):
        if root.m != -1:
            if end <= root.m: self.add(start, end, root.left)
            elif start >= root.m: self.add(start, end, root.right)
            else:
                self.add(start, root.m, root.left)
                self.add(root.m, end, root.right)
            return
        
        if start == root.l and end == root.r:
            root.count += 1
            self.max = max(self.max, root.count)
        elif start == root.l:
            root.m = end
            root.left = Node(start, root.m, root.count + 1)
            root.right = Node(root.m, root.r, root.count)
            self.max = max(self.max, root.count + 1)
        elif end == root.r:
            root.m = start;
            root.left = Node(root.l, root.m, root.count)
            root.right = Node(root.m, root.r, root.count + 1)
            self.max = max(self.max, root.count + 1)
        else:
            root.m = start
            root.left = Node(root.l, root.m, root.count)
            root.right = Node(root.m, root.r, root.count)
            self.add(start, end, root.right)

Related Problems:

• [解题报告] LeetCode 729. My Calendar I
• [解题报告] LeetCode 731. My Calendar II

The post 花花酱 LeetCode 732. My Calendar III appeared first on Huahua's Tech Road.

Problem: 

Implement a MyCalendarTwo class to store your events. A new event can be added if adding the event will not cause a triple booking.

Your class will have one method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A triple booking happens when three events have some non-empty intersection (ie., there is some time that is common to all 3 events.)

For each call to the method MyCalendar.book, return true if the event can be added to the calendar successfully without causing a triple booking. Otherwise, return false and do not add the event to the calendar.

Your class will be called like this: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)

Example 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(50, 60); // returns true
MyCalendar.book(10, 40); // returns true
MyCalendar.book(5, 15); // returns false
MyCalendar.book(5, 10); // returns true
MyCalendar.book(25, 55); // returns true
Explanation<b>:</b> 
The first two events can be booked.  The third event can be double booked.
The fourth event (5, 15) can't be booked, because it would result in a triple booking.
The fifth event (5, 10) can be booked, as it does not use time 10 which is already double booked.
The sixth event (25, 55) can be booked, as the time in [25, 40) will be double booked with the third event;
the time [40, 50) will be single booked, and the time [50, 55) will be double booked with the second event.

Note:

• The number of calls to MyCalendar.book per test case will be at most 1000.
• In calls to MyCalendar.book(start, end), start and end are integers in the range [0, 10^9].

Idea:

Brute Force

Solution1:

Brute Force

Time Complexity: O(n^2)

Space Complexity: O(n)

// Author: Huahua
// Runtime: 82 ms
class MyCalendarTwo {
public:
    MyCalendarTwo() {}
    
    bool book(int start, int end) {
        for (const auto& kv : overlaps_)
            if (max(start, kv.first) < min(end, kv.second)) return false;
        
        for (const auto& kv : booked_) {
            const int ss = max(start, kv.first);
            const int ee = min(end, kv.second);
            if (ss < ee) overlaps_.emplace_back(ss, ee);
        }
        
        booked_.emplace_back(start, end);
        return true;
    }
private:
    vector<pair<int, int>> booked_;
    vector<pair<int, int>> overlaps_;
};

Java

// Author: Huahua
// Runtime: 156 ms
class MyCalendarTwo {
    
    private List<int[]> booked_;
    private List<int[]> overlaps_;

    public MyCalendarTwo() {
        booked_ = new ArrayList<>();
        overlaps_ = new ArrayList<>();
    }
    
    public boolean book(int start, int end) {
        for (int[] range : overlaps_)
            if (Math.max(range[0], start) < Math.min(range[1], end)) 
                return false;
        
        for (int[] range : booked_) {
            int ss = Math.max(range[0], start);
            int ee = Math.min(range[1], end);
            if (ss < ee) overlaps_.add(new int[]{ss, ee});
        }
        
        booked_.add(new int[]{start, end});
        return true;
    }

}

Python

"""
Author: Huahua
Runtime: 638 ms
"""
class MyCalendarTwo:

    def __init__(self):
        self.booked_ = []
        self.overlaps_ = []

    def book(self, start, end):
        for s, e in self.overlaps_:
            if start < e and end > s: return False
        
        for s, e in self.booked_:            
            if start < e and end > s: 
                self.overlaps_.append([max(start, s), min(end, e)])
        
        self.booked_.append([start, end])
        return True

Solution 2:

Counting

Time Complexity: O(n^2logn)

Space Complexity: O(n)

// Author: Huahua
// Runtime: 212 ms
class MyCalendarTwo {
public:
    MyCalendarTwo() {}
    
    bool book(int start, int end) {
        ++delta_[start];
        --delta_[end];
        int count = 0;
        for (const auto& kv : delta_) {
            count += kv.second;
            if (count == 3) {
                --delta_[start];
                ++delta_[end];
                return false;
            }
            if (kv.first > end) break;
        }
        return true;
    }
private:
    map<int, int> delta_;
};

Related Problems:

• [解题报告] LeetCode 729. My Calendar I
• [解题报告] LeetCode 715. Range Module
• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 699. Falling Squares

The post 花花酱 LeetCode 731. My Calendar II – 花花酱 appeared first on Huahua's Tech Road.

Problem:

Implement a MyCalendar class to store your events. A new event can be added if adding the event will not cause a double booking.

Your class will have the method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A double booking happens when two events have some non-empty intersection (ie., there is some time that is common to both events.)

For each call to the method MyCalendar.book, return true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.

Your class will be called like this: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)

Example 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
Explanation: 
The first event can be booked.  The second can't because time 15 is already booked by another event.
The third event can be booked, as the first event takes every time less than 20, but not including 20.

Note:

• The number of calls to MyCalendar.book per test case will be at most 1000.
• In calls to MyCalendar.book(start, end), start and end are integers in the range [0, 10^9].

Idea: 

Binary Search

Solution1:

Brute Force: O(n^2)

C++

// Author: Huahua
// Runtime: 99 ms
class MyCalendar {
public:
    MyCalendar() {}
    
    bool book(int start, int end) {        
        for (const auto& event : booked_) {
            int s = event.first;
            int e = event.second;          
            if (max(s, start) < min(e, end)) return false;
        }       
        booked_.emplace_back(start, end);        
        return true;
    }
private:
    vector<pair<int, int>> booked_;
};

Solution 2:

Binary Search O(nlogn)

C++

// Author: Huahua
// Runtime: 82 ms
class MyCalendar {
public:
    MyCalendar() {}
    
    bool book(int start, int end) {        
        auto it = booked_.lower_bound(start);
        if (it != booked_.cend() && it->first < end)
            return false;        
        if (it != booked_.cbegin() && (--it)->second > start)
            return false;        
        booked_[start] = end;
        return true;
    }
private:
    map<int, int> booked_;
};

Java

// Author: Huahua
// Runtime: 170 ms
class MyCalendar {
    TreeMap<Integer, Integer> booked_;
    public MyCalendar() {
        booked_ = new TreeMap<>();
    }
    
    public boolean book(int start, int end) {
        Integer lb = booked_.floorKey(start);
        if (lb != null && booked_.get(lb) > start) return false;
        Integer ub = booked_.ceilingKey(start);
        if (ub != null && ub < end) return false;

        booked_.put(start, end);
        return true;
    }
}

Related Problems:

• [解题报告] LeetCode 731. My Calendar II
• [解题报告] LeetCode 715. Range Module
• [解题报告] LeetCode 699. Falling Squares
• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 57. Insert Interval

The post 花花酱 LeetCode 729. My Calendar I appeared first on Huahua's Tech Road.

题目大意：方块落下后会堆叠在重叠的方块之上，问每一块方块落下之后最高的方块的高度是多少？

Problem:

On an infinite number line (x-axis), we drop given squares in the order they are given.

The i-th square dropped (positions[i] = (left, side_length)) is a square with the left-most point being positions[i][0] and sidelength positions[i][1].

The square is dropped with the bottom edge parallel to the number line, and from a higher height than all currently landed squares. We wait for each square to stick before dropping the next.

The squares are infinitely sticky on their bottom edge, and will remain fixed to any positive length surface they touch (either the number line or another square). Squares dropped adjacent to each other will not stick together prematurely.

Return a list ans of heights. Each height ans[i] represents the current highest height of any square we have dropped, after dropping squares represented by positions[0], positions[1], ..., positions[i].

Example 1:

Input: [[1, 2], [2, 3], [6, 1]]
Output: [2, 5, 5]
Explanation:

After the first drop of 
positions[0] = [1, 2]:
_aa
_aa
-------
The maximum height of any square is 2.


After the second drop of 
positions[1] = [2, 3]:
__aaa
__aaa
__aaa
_aa__
_aa__
--------------
The maximum height of any square is 5.  
The larger square stays on top of the smaller square despite where its center
of gravity is, because squares are infinitely sticky on their bottom edge.


After the third drop of 
positions[1] = [6, 1]:
__aaa
__aaa
__aaa
_aa
_aa___a
--------------
The maximum height of any square is still 5.

Thus, we return an answer of 
[2, 5, 5]

Example 2:

Input: [[100, 100], [200, 100]]
Output: [100, 100]
Explanation: Adjacent squares don't get stuck prematurely - only their bottom edge can stick to surfaces.

Note:

• 1 <= positions.length <= 1000.
• 1 <= positions[i][0] <= 10^8.
• 1 <= positions[i][1] <= 10^6.

Idea:

Range query with map

Solution:

C++ map

// Author: Huahua
// Runtime: 29 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        map<pair<int, int>, int> b; // {{start, end}, height}        
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int size = kv.second;
            int end = start + size;
            // first range intersect with new_interval
            auto it = b.upper_bound({start, end});
            if (it != b.begin()) {
                auto it2 = it;
                if ((--it2)->first.second > start) it = it2;
            }
            
            int baseHeight = 0;
            vector<tuple<int, int, int>> ranges;
            while (it != b.end() && it->first.first < end) {
                const int s = it->first.first;
                const int e = it->first.second;
                const int h = it->second;
                if (s < start) ranges.emplace_back(s, start, h);
                if (e > end) ranges.emplace_back(end, e, h);
                // max height of intesected ranges
                baseHeight = max(baseHeight, h);
                it = b.erase(it);
            }
            
            int newHeight = size + baseHeight;
            
            b[{start, end}] = newHeight;
            
            for (const auto& range: ranges)
                b[{get<0>(range), get<1>(range)}] = get<2>(range);
            
            maxHeight = max(maxHeight, newHeight);            
            ans.push_back(maxHeight);
        }
        return ans;
    }
};

C++ vector without merge

// Author: Huahua
// Runtime: 46 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        vector<Interval> intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start)             
                    continue;
                baseHeight = max(baseHeight, interval.height);
            }
            int height = kv.second + baseHeight;
            intervals.push_back(Interval(start, end, height));
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

C++ / vector with merge (slower)

// Author: Huahua
// Runtime: 86 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        vector<Interval> intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            vector<Interval> tmp;
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start) {
                    tmp.push_back(interval);                
                    continue;
                }
                baseHeight = max(baseHeight, interval.height);
                if (interval.start < start || interval.end > end)
                    tmp.push_back(interval);
            }
            int height = kv.second + baseHeight;
            tmp.push_back(Interval(start, end, height));
            intervals.swap(tmp);
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

Related Problems:

• [解题报告] LeetCode 715. Range Module
• [解题报告] LeetCode 218. The Skyline Problem
• [解题报告] LeetCode 57. Insert Interval

The post 花花酱 LeetCode 699. Falling Squares appeared first on Huahua's Tech Road.

Problem:

A Range Module is a module that tracks ranges of numbers. Your task is to design and implement the following interfaces in an efficient manner.

• addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked.
• queryRange(int left, int right) Returns true if and only if every real number in the interval [left, right) is currently being tracked.
• removeRange(int left, int right) Stops tracking every real number currently being tracked in the interval [left, right).

Example 1:

addRange(10, 20): null
removeRange(14, 16): null
queryRange(10, 14): true (Every number in [10, 14) is being tracked)
queryRange(13, 15): false (Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked)
queryRange(16, 17): true (The number 16 in [16, 17) is still being tracked, despite the remove operation)

Note:

• A half open interval [left, right) denotes all real numbers left <= x < right.
• 0 < left < right < 10^9 in all calls to addRange, queryRange, removeRange.
• The total number of calls to addRange in a single test case is at most 1000.
• The total number of calls to queryRange in a single test case is at most 5000.
• The total number of calls to removeRange in a single test case is at most 1000.

Idea:

map / ordered ranges

Solution:

C++ / vector

// Author: Huahua
// Runtime: 276 ms
class RangeModule {
public:
    RangeModule() {}
    
    void addRange(int left, int right) {
        vector<pair<int, int>> new_ranges;
        bool inserted = false;
        for (const auto& kv : ranges_) {            
            if (kv.first > right && !inserted) {
                new_ranges.emplace_back(left, right);
                inserted = true;
            }
            if (kv.second < left || kv.first > right) { 
                new_ranges.push_back(kv);
            } else {
                left = min(left, kv.first);
                right = max(right, kv.second);
            }
        }       
        if (!inserted) new_ranges.emplace_back(left, right);       
        ranges_.swap(new_ranges);
    }
    
    bool queryRange(int left, int right) {
        const int n = ranges_.size();
        int l = 0;
        int r = n - 1;
        // Binary search
        while (l <= r) {
            int m = l + (r - l) / 2;
            if (ranges_[m].second < left)
                l = m + 1;
            else if (ranges_[m].first > right)
                r = m - 1;
            else
                return ranges_[m].first <= left && ranges_[m].second >= right;
        }
        return false;
    }
    
    void removeRange(int left, int right) {
        vector<pair<int, int>> new_ranges;        
        for (const auto& kv : ranges_) {
            if (kv.second <= left || kv.first >= right) {
                new_ranges.push_back(kv);
            } else {
                if (kv.first < left)
                    new_ranges.emplace_back(kv.first, left);
                if (kv.second > right)
                    new_ranges.emplace_back(right, kv.second);
            }        
        }
        ranges_.swap(new_ranges);
    }
    vector<pair<int, int>> ranges_;
};

C++ / map

// Author: Huahua
// Runtime: 199 ms
class RangeModule {
public:
    RangeModule() {}
    
    void addRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // At least one range overlapping with [left, right)
        if (l != r) {
            // Merge intervals into [left, right)
            auto last = r; --last;
            left = min(left, l->first);            
            right = max(right, last->second);
            // Remove all overlapped ranges
            ranges_.erase(l, r);
        }
        // Add a new/merged range
        ranges_[left] = right;
    }
    
    bool queryRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // No overlapping range
        if (l == r) return false;
        return l->first <= left && l->second >= right;
    }
    
    void removeRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // No overlapping range
        if (l == r) return;
        auto last = r; --last;
        int start = min(left, l->first);        
        int end = max(right, last->second);
        // Delete overlapping ranges        
        ranges_.erase(l, r);
        if (start < left) ranges_[start] = left;
        if (end > right) ranges_[right] = end;
    }
private:
    typedef map<int, int>::iterator IT;
    map<int, int> ranges_;
    void getOverlapRanges(int left, int right, IT& l, IT& r) {
        l = ranges_.upper_bound(left);
        r = ranges_.upper_bound(right);
        if (l != ranges_.begin())
            if ((--l)->second < left) l++;
    }
};

Related Problems:

• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 56. Merge Intervals

The post 花花酱 LeetCode 715. Range Module appeared first on Huahua's Tech Road.