洛谷P4364 IIIDX

题意：给定n个数和k，把n个数排成序列，满足a_i >= a_i/k，并使之字典序最大。

解：毒瘤线段树贪心...

以i/k为i的父亲构树。

当这n个数不同的时候，直接后序遍历贪心即可。

正解神奇的一批......

从大到小排序并建线段树，维护f_i为每个数自己及左边(大于等于它)之中有多少个数能选。

假设我们i位置选了x，i的siz是s，那么[x, n]的f值要减去s，表示其中s个数被i的子树预定了。

然后当我们算i的儿子的时候，就要把[x, n]的f加上siz son i，避免给自己预定的自己反而不能选。

如何确定x？要尽量大，所以在线段树上往左找。

一个数能被选，需要他的f值不小于siz i

这样我们发现样例都过不了。之前加[x, n]的时候，[1, x-1]没有改变，但是这是不对的，简略来说就是右边对左边有影响。

如果我们选了一个位置，但是右边有一个的f值却小于siz i了。那么你想啊，能选大的不能选小的，显然有问题。就是那个小的的左边都不够，你更靠左怎么可能够...

于是要求[x, n]的f全部不小于siz i。

选出来的x对应的值可能有多个，选择最右的那个。是因为这样有决策包容性？

还是有一点不懂，比如为什么不需要标记一个位置已被选，不怕选重复了吗？

#include <cstdio>
#include <algorithm>

const int N = 500010;

int n, a[N], siz[N], pos[N], fa[N], ans[N], X[N], xx;
double k;
int tag[N * 4], small[N * 4];

inline void pushdown(int o) {
    if(tag[o]) {
        tag[o << 1] += tag[o];
        tag[o << 1 | 1] += tag[o];
        small[o << 1] += tag[o];
        small[o << 1 | 1] += tag[o];
        tag[o] = 0;
    }
    return;
}

inline void add(int L, int R, int v, int l, int r, int o) {
    //printf("add : %d %d %d %d %d 
", L, R, v, l, r);
    if(L <= l && r <= R) {
        small[o] += v;
        tag[o] += v;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(o);
    if(L <= mid) {
        add(L, R, v, l, mid, o << 1);
    }
    if(mid < R) {
        add(L, R, v, mid + 1, r, o << 1 | 1);
    }
    small[o] = std::min(small[o << 1], small[o << 1 | 1]);
    //printf("min %d %d  = %d 
", l, r, small[o]);
    return;
}

inline int getpos(int k, int l, int r, int o) {
    //printf("ask %d %d %d 
", k, l, r);
    if(l == r) {
        return small[o] < k ? a[r + 1] : a[r];
    }
    int mid = (l + r) >> 1;
    pushdown(o);
    //printf("%d >= %d 
", small[o << 1 | 1], k);
    if(small[o << 1 | 1] >= k) {
        return getpos(k, l, mid, o << 1);
    }
    else {
        return getpos(k, mid + 1, r, o << 1 | 1);
    }
}

void build(int l, int r, int o) {
    if(l == r) {
        small[o] = r;
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, o << 1);
    build(mid + 1, r, o << 1 | 1);
    small[o] = std::min(small[o << 1], small[o << 1 | 1]);
    return;
}

int main() {
    scanf("%d%lf", &n, &k);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        X[i] = a[i];
    }
    std::sort(a + 1, a + n + 1);
    std::sort(X + 1, X + n + 1);
    std::reverse(a + 1, a + n + 1);
    int xx = std::unique(X + 1, X + n + 1) - X - 1;
    for(int i = n; i >= 1; i--) {
        a[i] = std::lower_bound(X + 1, X + xx + 1, a[i]) - X;
        siz[i]++;
        fa[i] = (i / k);
        siz[fa[i]] += siz[i];
    }

    for(int i = 1; i <= n; i++) {
        pos[a[i]] = i;
    }

    build(1, n, 1);

    for(int i = 1; i <= n; i++) {
        // choose i
        if(fa[i]) {
            add(ans[fa[i]], n, siz[i], 1, n, 1);
        }
        int t = getpos(siz[i], 1, n, 1);
        //printf("i = %d  t = %d 
", i, t);
        t = pos[t]--;
        // i choose t
        ans[i] = t;
        //printf("fa = %d 
", fa[i]);
        add(t, n, -siz[i], 1, n, 1);
    }

    for(int i = 1; i <= n; i++) {
        printf("%d ", X[a[ans[i]]]);
    }
    return 0;
}

总之很神。