九省联考2018D1T2 IIIDX

链接

很容易发现，歌曲间的关系构成了一棵树，于是O(n)的贪心算法也就是显然的。

但是我们对贪心带来的55~60分不满意，鉴于这个题是个nlogn范围，所以还是用数据结构吧。

很容易发现，题目给出的n首歌的难度顺序不会影响最终答案，所以首先对这个难度值从大到小排序。

不过树还是要构造的，接下来预处理出每个节点的子树大小。

之后，每次找一个最靠左的位置，使得这个位置左边足够放下当前节点的子树。如果有多个值相同，就放到最右边的值那里。

上面是最关键的一句话，想到这里，就突破了贪心狭隘的思路，并取得了成功的一半。

利用线段树维护每个位置左边（包括自身）还能放多大的子树，初始为1, 2, 3 ... n。

记录一个same数组表示与当前数字相同的值最靠右边的位置，然后每次查找时在线段树上二分，之后再放到最右边那里，记为pos。

放完之后，更新线段树，因为放了一棵树，所以使得pos位置和pos右边的所有位置左边的空间减少了当前节点的子树大小，就对线段树进行区间减操作。

时间复杂度O(nlogn)。

#include <iostream>
#include <algorithm>
#include <cstdio>

const int maxn = 5e5 + 7;

using namespace std;

int a[maxn];
int fa[maxn];
int ans[maxn];
int size[maxn];
int same[maxn];
int st[maxn << 2]; //线段树维护最小值
int add[maxn << 2];

inline int read()
{
    int X = 0; char ch = 0;
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') X = (X << 3) + (X << 1) + ch - '0', ch = getchar();
    return X;
}

inline bool cmp(int x, int y)
{
    return x > y;
}

inline void pushup(int rt)
{
    st[rt] = min(st[rt << 1], st[rt << 1 | 1]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        st[rt] = l; //初始为1 -> n的序列
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, rt << 1);
    build(mid + 1, r, rt << 1 | 1);
    pushup(rt);
}

inline void pushdown(int rt)
{
    if (add[rt]) {
        st[rt << 1] += add[rt];
        st[rt << 1 | 1] += add[rt];
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        add[rt] = 0;
    }
}

void update(int x, int y, int z, int l, int r, int rt)
{
    if (l >= x && r <= y) {
        st[rt] += z;
        add[rt] += z;
        return;
    }
    pushdown(rt);
    int mid = (l + r) >> 1;
    if (x <= mid) update(x, y, z, l, mid, rt << 1);
    if (y > mid) update(x, y, z, mid + 1, r, rt << 1 | 1);
    pushup(rt);
}

int find(int x, int l, int r, int rt) //线段树中的二分查找
{
    if (l == r) return l + (st[rt] < x);
    pushdown(rt);
    int ls = rt << 1, rs = ls | 1, mid = (l + r) >> 1;
    if (x <= st[rs]) return find(x, l, mid, ls);
    return find(x, mid + 1, r, rs);
}

int main(void)
{
    int n = read();
    double k;
    cin >> k;
    for (register int i = 1; i <= n; i++) a[i] = read();
    sort(a+1, a+n+1, cmp);
    for (register int i = n-1; i; i--) if (a[i] == a[i+1]) same[i] = same[i+1] + 1; //每个数与它右边连续几个数相同
    for (register int i = 1; i <= n; i++) fa[i] = int(i / k), size[i] = 1;
    for (register int i = n; i; i--) size[fa[i]] += size[i]; //预处理子树大小
    build(1, n, 1);
    for (register int i = 1; i <= n; i++) {
        if (fa[i] != fa[i-1]) update(ans[fa[i]], n, size[fa[i]] - 1, 1, n, 1); //维护单调性以保证二分查找的正确性
        int pos = find(size[i], 1, n, 1);
        pos += same[pos]; //传送到最右边相同值位置
        same[pos]++; //因为一个位置不能重复使用多次，所以第一遍传送到最右值之后，第二遍要传送到次右值，以此类推
        pos -= same[pos] - 1; //往回跳
        ans[i] = pos;
        update(pos, n, -size[i], 1, n, 1); //更新
    }
    for (register int i = 1; i <= n; i++) printf("%d ", a[ans[i]]);
    
    return 0;
}