<p>You are given an array of people, <code>people</code>, which are the attributes of some people in a queue (not necessarily in order). Each <code>people[i] = [h<sub>i</sub>, k<sub>i</sub>]</code> represents the <code>i<sup>th</sup></code> person of height <code>h<sub>i</sub></code> with <strong>exactly</strong> <code>k<sub>i</sub></code> other people in front who have a height greater than or equal to <code>h<sub>i</sub></code>.</p>

<p>Reconstruct and return <em>the queue that is represented by the input array </em><code>people</code>. The returned queue should be formatted as an array <code>queue</code>, where <code>queue[j] = [h<sub>j</sub>, k<sub>j</sub>]</code> is the attributes of the <code>j<sup>th</sup></code> person in the queue (<code>queue[0]</code> is the person at the front of the queue).</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
<strong>Output:</strong> [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
<strong>Explanation:</strong>
Person 0 has height 5 with no other people taller or the same height in front.
Person 1 has height 7 with no other people taller or the same height in front.
Person 2 has height 5 with two persons taller or the same height in front, which is person 0 and 1.
Person 3 has height 6 with one person taller or the same height in front, which is person 1.
Person 4 has height 4 with four people taller or the same height in front, which are people 0, 1, 2, and 3.
Person 5 has height 7 with one person taller or the same height in front, which is person 1.
Hence [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] is the reconstructed queue.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
<strong>Output:</strong> [[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= people.length &lt;= 2000</code></li>
	<li><code>0 &lt;= h<sub>i</sub> &lt;= 10<sup>6</sup></code></li>
	<li><code>0 &lt;= k<sub>i</sub> &lt; people.length</code></li>
	<li>It is guaranteed that the queue can be reconstructed.</li>
</ul>

class Solution {
public:
    vector<int> tree;
    int build(int node, int start, int end) {
        if(start == end) {
            tree[node - 1] = 1;
            return 1;
        }
        int mid = (start + end) / 2;
        int left = build(node * 2, start, mid);
        int right = build(node * 2 + 1, mid + 1, end);
        tree[node - 1] = left + right;
        return left + right;
    }

    void update(int node, int start, int end, int idx) {
        if(start == end) {
            tree[node - 1] = 0;
            return;
        }
        int mid = (start + end) / 2;
        if(idx <= mid) {
            update(node * 2, start, mid, idx);
        } else {
            update(node * 2 + 1, mid + 1, end, idx);
        }
        tree[node - 1] -= 1;
    }

    int find(int node, int start, int end, int count) {
        if(start == end) {
            return start;
        }
        int mid = (start + end) / 2;
        int left = tree[node * 2 - 1];
        int right = tree[node * 2];
        if(count <= left && left != 0) {
            return find(node * 2, start, mid, count);
        } else {
            return find(node * 2 + 1, mid + 1, end, count - left);
        }
    }

    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), [](vector<int>& a, vector<int>& b) {
            if(a[0] == b[0]) return a[1] > b[1];
            return a[0] < b[0];
        });

        tree.resize(0);
        int size = people.size();
        int tree_size = pow(2, ceil(log2(size)) + 1);
        tree.resize(tree_size);
        build(1, 0, size - 1);

        vector<vector<int>> result(size, vector<int>());
        for(int i = 0; i < size; i++) {
            int idx = find(1, 0, size - 1, people[i][1] + 1);
            result[idx] = people[i];
            update(1, 0, size - 1, idx);
        }

        return result;
    }
};
15600