Lena Sort 构造题，很多细节的模拟

https://www.hackerrank.com/contests/101hack46/challenges/lena-sort

把题目转换成一颗二叉树，也就是当前的节点是cur，然后大的，放右边，小的，放左边。

然后所有节点的深度总和，就是答案c。现在就是要你构造一颗这样的树。

最大的树就是左偏树，然后从最后一个节点开始模拟，如果它放移上一格，贡献就会 - 1，所以肯定能构造出一颗满意的树。

至于细节比较多，慢慢debug把。代码也非常混乱。

数据

15 18

7 12

主要是理解为什么这样就是答案。

其实每一个节点的贡献，就是路径的长度，路径的长度表示它被比较了多少次。

一直都是和它的祖先比较。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <assert.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;

#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <bitset>

const int maxn = 1e5 + ;
vector<int>G[maxn];
int findmin(int len) {
    if (len == ) return ;
    if (len == ) return ;
    return (len - ) * ;
}
LL findmax(int len) {
    return 1LL * len * (len - ) / ;
}
struct node {
    int cnt, deep;
    node(int a, int b) : cnt(a), deep(b) {}
};
queue<struct node> que;
int val;
int ans[maxn];
void show(int id) {
    if (G[id].size() == ) {
        ans[id] = val;
//        cout << val << " ";
        ++val;
        return;
    }
    show(G[id][]);
    ans[id] = val;
//    cout << val << " ";
    ++val;
    if (G[id].size() == ) {
        show(G[id][]);
    }
}
int check(vector<int> arr) {
    if (arr.size() <= ) return ;
    vector<int> les;
    vector<int> big;
    for (int i = ; i < arr.size(); ++i) {
        if (arr[i] > arr[]) big.push_back(arr[i]);
        else les.push_back(arr[i]);
    }
    return check(les) + check(big) + arr.size() - ;
}
int len, c;
void bfs(int cur) {
    queue<int>que;
    que.push(cur);
//    vector<int>t;
    while (!que.empty()) {
        int now = que.front();
        que.pop();
        cout << ans[now] << " ";
//        t.push_back(ans[now]);
        for (int i = ; i < G[now].size(); ++i) {
            que.push(G[now][i]);
        }
    }
//    if (check(t) != c) {
//        cout << "NO" << endl;
//    } else cout << "YES" << endl;
}
int deep[maxn];
void work() {
    cin >> len >> c;
    if (c > findmax(len)) {
        cout << - << endl;
        return;
    }
    LL cur = findmax(len);
    for (int i = ; i <= len; ++i) {
        G[i].clear();
        if (i != len) {
            G[i].push_back(i + );
        }
        deep[i] = i - ;
    }
    while (!que.empty()) que.pop();
    que.push(node(, ));
    int impo = ;
    for (int i = len; i >=  && cur > c; --i) {
        struct node t = que.front();
        int one = i - t.deep - ;
        int to = min(cur - c, one * 1LL);
        if (to <= ) {
            cout << - << endl;
            return;
        }
        if (one == to) {
            G[t.cnt].push_back(i);
            deep[i] = deep[t.cnt] + ;
            G[i].clear();
            G[i - ].clear();
            if (G[t.cnt].size() == ) {
                if (t.cnt == impo) impo++;
                que.pop();
                que.push(node(G[t.cnt][], t.deep + ));
                que.push(node(G[t.cnt][], t.deep + ));
            }
        } else {
            G[i].clear();
            G[i - ].clear();
            for (int j = ; j <= len; ++j) {
                if (deep[i] == deep[j] + to + ) {
                    G[j].push_back(i);
                    break;
                }
            }
            break;
        }
        cur -= to;
    }
    val = ;
    show();
    bfs();
//    vector<int> t;
//    for (int i = 1; i <= len; ++i) {
//        cout << ans[i] << " ";
//        t.push_back(ans[i]);
//    }
//    cout << "****" << check(t);
    cout << endl;
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    while (t--) work();
    return ;
}