<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<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        int n=people.size();
        new_sort(people);
        vector<int> v(n);
        vector<int> r;
        for(int i=0;i<v.size();i++){
            if(people[i][1]==0){
                v[i]=1;
                r.push_back(people[i][0]);
            }
        }
        sort(r.begin(),r.end());
        vector<vector<int>> res;
        for(int i=0;i<r.size();i++){
            vector<int>e(2);
            e[0]=r[i];
            res.push_back(e);
        }
        for(int i=0;i<n;i++){
            if(v[i]==0){
                // cout<<people[i][0]<<" "<<people[i][1]<<"\n";
                joiner(res,people[i]);
            }
        }
        return res;


    }
    void joiner(vector<vector<int>> &res,vector<int> d){
        if(res.size()<=d[1]){
            res.push_back(d);
            return;
        }
        int count=0;
        vector<int> swap=d;
        vector<int> c=d;
        for(int i=0;i<res.size();i++){
            if(res[i][0]>=d[0]){
                count++;
            }
            if(count==d[1]){
                for(int j=i+1;j<res.size();j++){
                    c=res[j];
                    res[j]=swap;
                    swap=c;
                }
                res.push_back(c);
                break;
            }
            
        }
        
    }
    void new_sort(vector<vector<int>> &p){
        map<int,vector<int>> m;
        for(int i=0;i<p.size();i++){
            if(m.find(p[i][0])==m.end()){
                vector<int> r;
                r.push_back(p[i][1]);
                m[p[i][0]]=r;
            }
            else{
                m[p[i][0]].push_back(p[i][1]);
            }
        }
        p=vector<vector<int>>();
        for(auto it=m.rbegin();it!=m.rend();it++){
            vector<int>q=it->second;
            sort(q.begin(),q.end());
            for(int j=0;j<q.size();j++){
                vector<int>s(2,it->first);
                s[1]=q[j];
                p.push_back(s);
            }
        }
    }
};
23100