[九省联考2018]IIIDX

题目

传送门 to luogu

题目概要
给你一个正整数 $k$ ，求给定的 $n$ 个数的一种排列，满足 $a_i\ge a_{\lfloor \frac{i}{k}\rfloor }$（可以认为 $a_0=-\infty$）。

如果有多种解，输出字典序最大的一个。

数据范围与约定
对于所有数据，$n\le 5\times 10^5,1<k\le 10^9,1\le a_i\le 10^9$ 。

数据 不保证 $a_i$ 互不相同。

思路

感谢@ww3113306 的博客提供的思路。代码是直接复制的。

由于 $1<k$ ，将所有 $i,\lfloor \frac{i}{k}\rfloor$ 连边，显然它是一棵树，以 $0$ 为根节点。

此时，这棵树就满足小根堆性质。

对于一个点 $x$ ，假如它的子树大小为 $c$ ，那么就 至少有 $c$ 个数大于等于 $a_x$ 。

我们从小到大枚举每一个数，问题就是找到一个最大的 $x$ ，使得大于等于 $x$ 的数不小于 $x$ 的子树大小。

这似乎很简单。问题是，我们需要 带修改 啊？否则你怎么表示 $1,2,3,\dots ,i-1$ 已经使用了哪些点呢？

用 $f(x)$ 表示大于等于 $x$ 的数还剩下多少个，假设 $a_i=x$ ，那么 $\forall y\le x,f(y)$ 会变小 $c$ 。之所以是 $c$ 而不是 $1$ ，因为我们要 提前把 $c$ 个数字都预定好（否则别人就把你的原计划中的儿子抢了）！

这就是个区间减法嘛。于是我们用一个 线段树 ，来保存这个 $f(x)$ ，剩下的事就很简单了……

然而事情远没有想象的那么简单！

显然的结论，$f(x)\ge f(x+1)$ 。毕竟 $f(x)$ 统计 $[x,+\infty )$ ，而 $f(x+1)$ 统计子区间 $[x+1,+\infty )$ 。

在修改的时候，我们只将 $y\le x$ 的 $f(y)$ 进行了修改，是因为我们还 不清楚 $x<y$ 的 $f(y)$ 会如何改动。事实上，所有的 $f(y)$ 都会被更改。

这又如何？我们有 $f(x)\ge f(x+1)$ 。所以很重要的式子就出现了——

$$F(n)=\underset{x=1}{\overset{n}{\min }}f(x)$$

其中 $F(n)$ 表示 真正的 剩余个数，$f(x)$ 是我们线段树维护的东西。

很巧，我们用线段树可以解决区间最小值的问题。但是有不严谨的地方：为什么 $F(n)={\min }_{x=1}^{n}f(x)$ ，而不是比其更小？所以我们改一下措辞：$F(n)$ 表示实际情况下，最多 剩余多少个。

因为 $F(n)$ 是后缀和，只要作差后是自然数，就可以还原出每个数字剩余多少个。

好像问题解决了？ $\mathtt{N}\mathtt{a}\mathtt{i}\mathtt{v}\mathtt{e}$！这可是道黑题啊！

父节点可能已经为你预定了数字。它把 $f(y)$ 减少了 $c$ ，已经用了 $c$ 个数字。那么你在用这些数字的时候，就可以直接使用。更具体地，你直接把父节点占的座位 “还回去” 即可——你和你的兄弟是挨着考虑的，还回去的点不会被乱用：把你和兄弟都考虑完，就把父节点预定的数字全部使用 $\mathtt{o}\mathtt{r}$ 预定了。

代码

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 551000
#define ac 2500000
/* 用一个好名字，说不定就能多A几组 */

int n, w, go, tot, rnt;
double k;
int ans[AC], cnt[AC], father[AC], Size[AC], f[AC], s[AC];// cnt[i]表示排名第i位的d值出现的次数 
bool done[AC];

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

inline int Min(int a, int b){
    return a > b ? b : a;
}

struct seg_tree{
    int tree[ac], lazy[ac], l[ac], r[ac];

    inline void update(int x){
        tree[x] = Min(tree[x * 2], tree[x * 2 + 1]);
    }

    inline void pushdown(int x)
    {
        if(lazy[x])
        {
            int ll = x * 2, rr = ll + 1;
            tree[ll] += lazy[x], tree[rr] += lazy[x];
            lazy[ll] += lazy[x], lazy[rr] += lazy[x];
            lazy[x] = 0;
        }
    }

    void build(int x, int ll, int rr)
    {
        l[x] = ll, r[x] = rr;
        if(ll == rr){tree[x] = f[ll]; return ;}
        int mid = (ll + rr) >> 1;
        build(x * 2, ll, mid), build(x * 2 + 1, mid + 1, rr);
        update(x);
    }

    void change(int x, int ll, int rr)
    { /* 区间减（可以让x为负数嘛） */
        pushdown(x);
        if(l[x] == ll && r[x] == rr)
        {
            tree[x] += w, lazy[x] += w;
            return ;
        }
        int mid = (l[x] + r[x]) >> 1;
        if(rr <= mid) change(x * 2, ll, rr);
        else if(ll > mid) change(x * 2 + 1, ll, rr);
        else change(x * 2, ll, mid), change(x * 2 + 1, mid + 1, rr);
        update(x);
    }

    void find(int x)
    { /* 找到第一个不小于w的F(x)，返回x */
        pushdown(x);
        if(l[x] == r[x]){
        	go = tree[x] >= w ? l[x] : l[x] - 1;
        	/* 最后的挣扎，看一下是自己还是左边一个 */
        	return ;
        }
        if(tree[x * 2] >= w) find(x * 2 + 1);
        /* 如果左边的最小值不小于w，那么答案才可能在右边 */
        else find(x * 2); 
        /* 否则一定在左边 */
        update(x);
    }
}T;

void pre()
{
    n = read(), scanf("%lf", &k);
    for(R i = 1; i <= n; i ++)
    	s[i] = read(), Size[i] = 1;
    sort(s + 1, s + n + 1);
    for(R i = 1; i <= n; i ++)
    { /* 类似于Hash的过程，s是排序去重后数组、cnt是对Hash值桶排 */
        ++ cnt[tot + 1];
        if(s[i] != s[i + 1]) s[++tot] = s[i];
    }
    for(R i = tot; i; i --)
        f[i] = f[i + 1] + cnt[i];
    // 存下每个值右边有多少个可供选择的值
    for(R i = n; i; i --) 
        father[i] = floor(i / k), Size[father[i]] += Size[i];
    // 获取每个节点的子树大小 
    T.build(1, 1, tot);
}

void work()
{
    for(R i = 1; i <= n; i ++)
    {
        int fa = floor(i / k); /* 父亲节点 */
        if(fa && !done[fa]) w = Size[fa] - 1, T.change(1, 1, ans[fa]);
        // 如果有父亲的话，要先把给儿子预定的节点还回来以帮助正确判断
        /* done数组用来确保每个父节点只“归还预定”一次 */
        w = Size[i], done[fa] = true;
        T.find(1), w = -Size[i];// 先找到一个合法的点
        T.change(1, 1, go);// 再减去已经被预定的位置
        ans[i] = go;
        printf("%d ", s[go]); 
    }
    printf("\n");
}

int main()
{
    pre(); /* prepare */
    work();
    return 0;
}