<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>

#include <algorithm>
#include <list>
#include <vector>
using namespace std;

class Solution {
   public:
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), [&](const auto& p1, const auto& p2) {
            return h_val(p1) * 2000 + k_val(p1) < h_val(p2) * 2000 + k_val(p2);
        });

        for (auto it{people.begin()}; it != people.end();) {
            auto p_count{k_val(it)};
            k_val(it) = add_fixed(k_val(it));
            if (p_count) {
                for (auto l_it{people.begin()}; l_it != it; ++l_it)
                    if (h_val(it) <= h_val(l_it)) --p_count;
                auto keeper{move(*it)};
                auto it_prev{it};
                auto it_next{it + 1};
                while (p_count) {
                    if (is_fixed(k_val(it_next))) {
                        if (h_val(keeper) <= h_val(it_next)) --p_count;
                    } else {
                        --p_count;
                        *it_prev = move(*it_next);
                        it_prev = it_next;
                    }
                    ++it_next;
                }
                *it_prev = move(keeper);
            }
            while (it != people.end() && is_fixed(k_val(it))) ++it;
        }
        for (auto&& prsn : people) {
            k_val(prsn) = rem_fixed(k_val(prsn));
        }
        return move(people);
    }

   private:
    static inline int& h_val(vector<int>& v) { return v[0]; };
    static inline const int& h_val(const vector<int>& v) { return v[0]; };
    static inline int& h_val(std::vector<std::vector<int>>::iterator& it) {
        return (*it)[0];
    };
    static inline int& k_val(vector<int>& v) { return v[1]; };
    static inline const int& k_val(const vector<int>& v) { return v[1]; };
    static inline int& k_val(std::vector<std::vector<int>>::iterator& it) {
        return (*it)[1];
    };
    constexpr bool is_fixed(int k) { return k & 2048; }
    constexpr int add_fixed(int k) { return k | 2048; }
    constexpr int rem_fixed(int k) { return k ^ 2048; }
};
14500