Return an integer array answer of size n, where answer[i] is the number of flowers that are in full bloom when the ith person arrives.

Example 1:

Input: flowers = [[1,6],[3,7],[9,12],[4,13]], persons = [2,3,7,11]
Output: [1,2,2,2]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

Example 2:

Input: flowers = [[1,10],[3,3]], persons = [3,3,2]
Output: [2,2,1]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

Constraints:

• 1 <= flowers.length <= 5 * 104
• flowers[i].length == 2
• 1 <= starti <= endi <= 109
• 1 <= persons.length <= 5 * 104
• 1 <= persons[i] <= 109

Solution: Prefix Sum + Binary Search

Use a treemap to store the counts (ordered by time t), when a flower begins to bloom at start, we increase m[start], when it dies at end, we decrease m[end+1]. prefix_sum[t] indicates the # of blooming flowers at time t.

For each people, use binary search to find the latest # of flowers before his arrival.

Time complexity: O(nlogn + mlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<int> fullBloomFlowers(vector<vector<int>>& flowers, vector<int>& persons) {
    map<int, int> m{{0, 0}};
    for (const auto& f : flowers)
      ++m[f[0]], --m[f[1] + 1];    
    int sum = 0;
    for (auto& [t, c] : m)
      c = sum += c;    
    vector<int> ans;    
    for (int t : persons)      
      ans.push_back(prev(m.upper_bound(t))->second);
    return ans;
  }
};

The post 花花酱 LeetCode 2251. Number of Flowers in Full Bloom appeared first on Huahua's Tech Road.

• i + minJump <= j <= min(i + maxJump, s.length - 1), and
• s[j] == '0'.

Return true if you can reach index s.length - 1 in s, or false otherwise.

Example 1:

Input: s = "011010", minJump = 2, maxJump = 3
Output: true
Explanation:
In the first step, move from index 0 to index 3. 
In the second step, move from index 3 to index 5.

Example 2:

Input: s = "01101110", minJump = 2, maxJump = 3
Output: false

Constraints:

• 2 <= s.length <= 105
• s[i] is either '0' or '1'.
• s[0] == '0'
• 1 <= minJump <= maxJump < s.length

Solution 1: TreeSet /Dequq + Binary Search

Maintain a set of reachable indices so far, for each ‘0’ index check whether it can be reached from any of the elements in the set.

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

// Author: Huahua, 296 ms, 59.7MB
class Solution {
public:
  bool canReach(string s, int minJump, int maxJump) {
    if (s.back() != '0') return false;
    const int n = s.length();    
    set<int> seen{0};
    for (int i = minJump; i < n; ++i) {
      if (s[i] != '0') continue;
      while (!seen.empty() && (*seen.begin()) + maxJump < i)
        seen.erase(seen.begin());
      auto it = seen.upper_bound(i - minJump);
      if (it != seen.begin() && *prev(it) + minJump <= i)        
        seen.insert(i);
    }
    return seen.count(n - 1);
  }
};

// Author: Huahua, 280 ms, 19MB
class Solution {
public:
  bool canReach(string s, int minJump, int maxJump) {
    if (s.back() != '0') return false;
    const int n = s.length();    
    deque<int> seen{0};
    for (int i = minJump; i < n; ++i) {
      if (s[i] != '0') continue;
      while (!seen.empty() && (seen.front()) + maxJump < i)
        seen.pop_front();
      auto it = upper_bound(begin(seen), end(seen), i - minJump);
      if (it != seen.begin() && *prev(it) + minJump <= i)
        seen.push_back(i);
    }
    return seen.back() == n - 1;
  }
};

Solution 2: Queue

Same idea, we can replace the deque in sol1 with a queue, and only check the smallest element in the queue.

// Author: Huahua, 56ms, 19.2MB
class Solution {
public:
  bool canReach(string s, int minJump, int maxJump) {
    if (s.back() != '0') return false;
    const int n = s.length();    
    queue<int> q{{0}};
    for (int i = minJump; i < n; ++i) {
      if (s[i] != '0') continue;
      while (!q.empty() && q.front() + maxJump < i)
        q.pop();
      if (!q.empty() && q.front() + minJump <= i)
        q.push(i);
    }
    return q.back() == n - 1;
  }
};

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

The post 花花酱 LeetCode 1871. Jump Game VII appeared first on Huahua's Tech Road.

Return the maximum total sum of all requests among all permutations of nums.

Since the answer may be too large, return it modulo 109 + 7.

Example 1:

Input: nums = [1,2,3,4,5], requests = [[1,3],[0,1]]
Output: 19
Explanation: One permutation of nums is [2,1,3,4,5] with the following result: 
requests[0] -> nums[1] + nums[2] + nums[3] = 1 + 3 + 4 = 8
requests[1] -> nums[0] + nums[1] = 2 + 1 = 3
Total sum: 8 + 3 = 11.
A permutation with a higher total sum is [3,5,4,2,1] with the following result:
requests[0] -> nums[1] + nums[2] + nums[3] = 5 + 4 + 2 = 11
requests[1] -> nums[0] + nums[1] = 3 + 5  = 8
Total sum: 11 + 8 = 19, which is the best that you can do.

Example 2:

Input: nums = [1,2,3,4,5,6], requests = [[0,1]]
Output: 11
Explanation: A permutation with the max total sum is [6,5,4,3,2,1] with request sums [11].

Example 3:

Input: nums = [1,2,3,4,5,10], requests = [[0,2],[1,3],[1,1]]
Output: 47
Explanation: A permutation with the max total sum is [4,10,5,3,2,1] with request sums [19,18,10].

Constraints:

• n == nums.length
• 1 <= n <= 105
• 0 <= nums[i] <= 105
• 1 <= requests.length <= 105
• requests[i].length == 2
• 0 <= starti <= endi < n

Solution: Greedy + Sweep line

Sort the numbers, and sort the frequency of each index, it’s easy to show largest number with largest frequency gives us max sum.

ans = sum(nums[i] * freq[i])

We can use sweep line to compute the frequency of each index in O(n) time and space.

For each request [start, end] : ++freq[start], –freq[end + 1]

Then the prefix sum of freq array is the frequency for each index.

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

class Solution {
public:
  int maxSumRangeQuery(vector<int>& nums, vector<vector<int>>& requests) {
    constexpr int kMod = 1e9 + 7;
    const int n = nums.size();    
    vector<long> freq(n);
    for (const auto& r : requests) {
      ++freq[r[0]];
      if (r[1] + 1 < n) --freq[r[1] + 1];
    }
    for (int i = 1; i < n; ++i)
      freq[i] += freq[i - 1];
    
    sort(begin(freq), end(freq));
    sort(begin(nums), end(nums));
    
    long ans = 0;
    for (int i = 0; i < n; ++i)
      ans += freq[i] * nums[i];
    
    return ans % kMod;
  }
};

The post 花花酱 LeetCode 1589. Maximum Sum Obtained of Any Permutation appeared first on Huahua's Tech Road.

Problem

There are a number of spherical balloons spread in two-dimensional space. For each balloon, provided input is the start and end coordinates of the horizontal diameter. Since it’s horizontal, y-coordinates don’t matter and hence the x-coordinates of start and end of the diameter suffice. Start is always smaller than end. There will be at most 10⁴ balloons.

An arrow can be shot up exactly vertically from different points along the x-axis. A balloon with x_start and x_endbursts by an arrow shot at x if x_start ≤ x ≤ x_end. There is no limit to the number of arrows that can be shot. An arrow once shot keeps travelling up infinitely. The problem is to find the minimum number of arrows that must be shot to burst all balloons.

Example:

Input:
[[10,16], [2,8], [1,6], [7,12]]

Output:
2

Explanation:
One way is to shoot one arrow for example at x = 6 (bursting the balloons [2,8] and [1,6]) and another arrow at x = 11 (bursting the other two balloons).

Solution: Sweep Line

Time complexity: O(nlogn)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 82 ms
class Solution {
public:
  int findMinArrowShots(vector<pair<int, int>>& points) {
    if (points.empty()) return 0;
    sort(points.begin(), points.end(), 
         [&](const pair<int,int>& a, const pair<int,int>& b){
           return a.second < b.second;
         });
    int right = points.front().second;
    int ans = 1;
    for (const auto& point : points) {
      if (point.first > right) {
        right = point.second;
        ++ans;
      }
    }
    return ans;
  }
};

Related Problems

• 花花酱 LeetCode 56. Merge Intervals
• 花花酱 LeetCode 57. Insert Interval
• 花花酱 LeetCode 759. Employee Free Time
• 花花酱 LeetCode 729. My Calendar I
• 花花酱 LeetCode 731. My Calendar II – 花花酱
• 花花酱 LeetCode 732. My Calendar III

The post 花花酱 LeetCode 452. Minimum Number of Arrows to Burst Balloons appeared first on Huahua's Tech Road.

题目大意：给你每个员工的日历，让你找出所有员工都有空的时间段。

Problem:

We are given a list schedule of employees, which represents the working time for each employee.

Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.

Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.

Example 1:

Input: schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]]
Output: [[3,4]]
Explanation:
There are a total of three employees, and all common
free time intervals would be [-inf, 1], [3, 4], [10, inf].
We discard any intervals that contain inf as they aren't finite.

Example 2:

Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]
Output: [[5,6],[7,9]]

(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2, and schedule[0][0][0] is not defined.)

Also, we wouldn’t include intervals like [5, 5] in our answer, as they have zero length.

Note:

1. schedule and schedule[i] are lists with lengths in range [1, 50].
2. 0 <= schedule[i].start < schedule[i].end <= 10^8.

Idea:

Merge Intervals (virtually)

Solution:

C++

Time complexity: O(nlogn)

Space complexity: O(n)

n is the total number of intervals, n <= 2500

// Author: Huahua
// Running time: 81 ms
class Solution {
public:
    vector<Interval> employeeFreeTime(vector<vector<Interval>>& schedule) {
      vector<Interval> all;
      for (const auto intervals : schedule)
        all.insert(all.end(), intervals.begin(), intervals.end());
      std::sort(all.begin(), all.end(), 
                [](const Interval& a, const Interval& b){
                  return a.start < b.start;
                });
      vector<Interval> ans;
      int end = all.front().end;
      for (const Interval& busy : all) {
        if (busy.start > end) 
          ans.emplace_back(end, busy.start);  
        end = max(end, busy.end);
      }
      return ans;
    }
};

Related Problems:

• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 729. My Calendar – 花花酱
• [解题报告] LeetCode 731. My Calendar II – 花花酱
• 花花酱 LeetCode 732. My Calendar III

The post 花花酱 LeetCode 759. Employee Free Time 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:

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Idea:

Sweep line

Solution:

C++

// Author: Huahua
// Runtime: 12 ms
class Solution {
public:
    vector<Interval> merge(vector<Interval>& intervals) {
        if (intervals.empty()) return {};
        
        std::sort(intervals.begin(), intervals.end(), 
                  [](const Interval& a, const Interval& b){
                        return a.start < b.start;
                    });
        
        vector<Interval> ans;        
        for (const auto& interval : intervals) {
            if (ans.empty() || interval.start > ans.back().end) {
                ans.push_back(interval);
            } else {
                ans.back().end = max(ans.back().end, interval.end);
            }
        }
        
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 69 ms
"""
class Solution(object):
    def merge(self, intervals):
        ans = []
        for interval in sorted(intervals, key=lambda x: x.start):
            if not ans or interval.start > ans[-1].end:
                ans.append(interval)
            else:
                ans[-1].end = max(ans[-1].end, interval.end)
        return ans

Related Problems:

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

The post 花花酱 LeetCode 56. Merge Intervals appeared first on Huahua's Tech Road.

Problem:

A city’s skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are given the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B).

The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi], where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively, and Hi is its height. It is guaranteed that 0 ≤ Li, Ri ≤ INT_MAX, 0 < Hi ≤ INT_MAX, and Ri - Li > 0. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

For instance, the dimensions of all buildings in Figure A are recorded as: [ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] .

The output is a list of “key points” (red dots in Figure B) in the format of [ [x1,y1], [x2, y2], [x3, y3], ... ] that uniquely defines a skyline. A key point is the left endpoint of a horizontal line segment. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour.

For instance, the skyline in Figure B should be represented as:[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ].

Notes:

• The number of buildings in any input list is guaranteed to be in the range [0, 10000].
• The input list is already sorted in ascending order by the left x position Li.
• The output list must be sorted by the x position.
• There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...[2 3], [4 5], [12 7], ...]

Idea:

Sweep line

Time Complexity:

O(nlogn)

Space Complexity:

O(n)

Solution1: Heap 

class Solution {
public:
    vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
        // events,   x,   h,   id,  type (1=entering, -1=leaving)
        vector<Event> events;
        
        int id = 0;
        for (const auto& b : buildings) {
            events.push_back(Event{id, b[0], b[2], 1});
            events.push_back(Event{id, b[1], b[2], -1});
            ++id;
        }
        
        // Sort events by x
        sort(events.begin(), events.end());
        
        // Init the heap
        MaxHeap heap(buildings.size());
        
        vector<pair<int, int>> ans;
        // Process all the events
        for (const auto& event: events) {            
            int x = event.x;
            int h = event.h;
            int id = event.id;
            int type = event.type;            
            
            if (type == 1) {
                if (h > heap.Max()) 
                    ans.emplace_back(x, h);
                heap.Add(h, id);
            } else {
                heap.Remove(id);
                if (h > heap.Max())
                    ans.emplace_back(x, heap.Max());
            }            
        }
        
        return ans;
    }
private:
    struct Event {
        int id;
        int x;       
        int h;
        int type;
        
        // sort by x+, type-, h, 
        bool operator<(const Event& e) const {
            if (x == e.x)                
                // Entering event h from large to small
                // Leaving event h from small to large
                return type * h > e.type * e.h;
            
            return x < e.x;
        }
    };
    
    class MaxHeap {
    public:
        MaxHeap(int max_items): 
            idx_(max_items, -1), vals_(max_items), size_(0) {}
        
        // Add an item into the heap. O(log(n))
        void Add(int key, int id) {
            idx_[id] = size_;
            vals_[size_] = {key, id};
            ++size_;
            HeapifyUp(idx_[id]);
        }
        
        // Remove an item. O(log(n))
        void Remove(int id) {
            int idx_to_evict = idx_[id];
            // swap with the last element
            SwapNode(idx_to_evict, size_ - 1);
            --size_;
            HeapifyDown(idx_to_evict);
            HeapifyDown(idx_to_evict);
        }
        
        bool Empty() const {
            return size_ == 0;
        }
        
        // Return the max of heap
        int Max() const {
            return Empty() ? 0 : vals_.front().first;
        }
    private:
        void SwapNode(int i, int j) {
            if (i == j) return;
            std::swap(idx_[vals_[i].second], idx_[vals_[j].second]);
            std::swap(vals_[i], vals_[j]);
        }
        
        void HeapifyUp(int i) {
            while (i != 0)  {            
                int p = (i - 1) / 2;
                if (vals_[i].first <= vals_[p].first) 
                    return;

                SwapNode(i, p);                
                i = p;
            }
        }
        
        // Make the heap valid again. O(log(n))
        void HeapifyDown(int i) {
            while (true) {
                int c1 = i*2 + 1;
                int c2 = i*2 + 2;

                // No child
                if (c1 >= size_) return;

                // Get the index of the max child
                int c = (c2 < size_ 
                      && vals_[c2].first > vals_[c1].first ) ? c2 : c1;

                // If key[c] is greater than key[i], swap them and
                // continue to HeapifyDown(c)
                if (vals_[c].first <= vals_[i].first) 
                    return;
                
                SwapNode(c, i);
                i = c;
            }
        }
        
        // {key, id}
        vector<pair<int,int>> vals_;
        
        // Index of the i-th item in vals_ 
        vector<int> idx_;
        
        int size_;
    };
};

// Author: Huahua
// Running time: 91 ms (beats 79.1%)
class Solution {
    private MaxHeap heap;
    
    public List<int[]> getSkyline(int[][] buildings) {
        int n = buildings.length;        
        // {x, h, id}
        ArrayList<int[]> es = new ArrayList<int[]>();
        
        for (int i = 0; i < n; ++i) {
            es.add(new int[]{ buildings[i][0], buildings[i][2], i});
            es.add(new int[]{ buildings[i][1], -buildings[i][2], i});
        }
        
        es.sort((e1, e2) -> {
            return e1[0] == e2[0] ? e2[1] - e1[1] : e1[0] - e2[0]; });
        
        
        List<int[]> ans = new ArrayList<int[]>();
        
        heap = new MaxHeap(n);
        
        for (int[] e : es) {
            int x = e[0];
            int h = e[1];
            int id = e[2];
            
            Boolean entering = h > 0;
            h = Math.abs(h);
            
            if (entering) {
                if (h > heap.max())
                    ans.add(new int[]{x, h});
                heap.add(h, id);
            } else {
                heap.remove(id);
                if (h > heap.max())
                    ans.add(new int[]{x, heap.max()});
            }
        }
        
        return ans;
    }
    
    private class MaxHeap {
        // (key, id)
        private List<int[]> nodes;
        
        // idx[i] = index of building[i] in nodes
        private int[] idx;
        
        public MaxHeap(int size) {
            idx = new int[size];
            nodes = new ArrayList<int[]>();
        }
        
        public void add(int key, int id) {
            idx[id] = nodes.size();
            nodes.add(new int[]{key, id});
            heapifyUp(idx[id]);
        }
        
        public void remove(int id) {
            int idx_to_evict = idx[id];
            swapNode(idx_to_evict, nodes.size() - 1);
            idx[id] = -1;
            nodes.remove(nodes.size() - 1);
            heapifyUp(idx_to_evict);
            heapifyDown(idx_to_evict);
        }
        
        public Boolean empty() {
            return nodes.isEmpty();
        }
        
        public int max() {
            return empty() ? 0 : nodes.get(0)[0];
        }
        
        private void heapifyUp(int i) {            
            while (i != 0) {            
                int p = (i - 1) / 2;
                if (nodes.get(i)[0] <= nodes.get(p)[0])
                    return;
                
                swapNode(i, p);
                i = p;
            }
        }
        
        private void swapNode(int i, int j) {
            int tmpIdx = idx[nodes.get(i)[1]];
            idx[nodes.get(i)[1]] = idx[nodes.get(j)[1]];
            idx[nodes.get(j)[1]] = tmpIdx;

            int[] tmpNode = nodes.get(i);
            nodes.set(i, nodes.get(j));
            nodes.set(j, tmpNode);
        }
        
        private void heapifyDown(int i) {
            while (true) {
                int c1 = i*2 + 1;
                int c2 = i*2 + 2;

                if (c1 >= nodes.size()) return;

                int c = (c2 < nodes.size() 
                      && nodes.get(c2)[0] > nodes.get(c1)[0]) ? c2 : c1;
                
                if (nodes.get(c)[0] <= nodes.get(i)[0])
                    return;
                
                swapNode(c, i);
                i = c;
            }
        }
        
    }
}

Solution 2: Multiset

// Author: Huahua
// Time Complexity: O(nlogn)
// Space Complexity: O(n)
// Running Time: 22 ms
class Solution {
public:
    vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
        typedef pair<int, int> Event; 
        // events,  x,   h
        vector<Event> es;        
        hs_.clear();
        
        for (const auto& b : buildings) {
            es.emplace_back(b[0], b[2]);
            es.emplace_back(b[1], -b[2]);
        }
        
        // Sort events by x
        sort(es.begin(), es.end(), [](const Event& e1, const Event& e2){
            if (e1.first == e2.first) return e1.second > e2.second;
            return e1.first < e2.first;
        });
        
        vector<pair<int, int>> ans;
        
        // Process all the events
        for (const auto& e: es) {            
            int x = e.first;
            bool entering = e.second > 0;
            int h = abs(e.second);
            
            if (entering) {                
                if (h > this->maxHeight()) 
                    ans.emplace_back(x, h);
                hs_.insert(h);
            } else {
                hs_.erase(hs_.equal_range(h).first);
                if (h > this->maxHeight())
                    ans.emplace_back(x, this->maxHeight());
            }            
        }
        
        return ans;
    }
private:
    int maxHeight() const {
        if (hs_.empty()) return 0;
        return *hs_.rbegin();
    }
    multiset<int> hs_;
};

The post 花花酱 LeetCode 218. The Skyline Problem appeared first on Huahua's Tech Road.