bzoj 5249 [九省联考2018]iiidx (线段树+贪心)

题目大意：给你一个序列，让你对它重新排列，保证a[i]<=a[i/k]，求字典序最大的排列

洛谷传送门

把i/k和i连边，发现形成了一个类似于小根堆的树形结构

先是一个错误的贪心：贪心每次选择前size[x]大个数依次填到树里

这种方法在有重复数字的时候会出锅，比如1112，如果用上面的方法就是1112，但正确的是1121

原因呢，就是填满一颗子树内并不一定要用完偏大的，可能和子树根同一深度的另一个节点可以取到更大的，比如有很多1，很少的2，我可能只要一些1就能把这棵子树填满，然后留给一些2给后面的子树去填。

然后我想了一个splay维护的贪心，就是相同的只取能填满子树且偏小的，但被我自己hack掉了，因为后面的子树不一定用光大的，可以把大的留给前面的来保证字典序最大

所以题解的方法还是很神的，用线段树来维护这个贪心

建一颗维护最小值和区间修改的线段树，维护一个变量F[i]表示 i 之前还有多少个节点可用

每次预留出size[x]个，在线段树上二分找到一个最小位置 i 满足F[k]>=size[x](k=i...n)，那么这个点的答案就是a[i]，如果有多个相同的，就找最后一个，可以预处理一个Last来解决，如果取过了某个节点就lasta[a[i]]--(因为所有相同的a[i]是等价的所以不用考虑位置)，a[i]比较大需要离散。然后区间修改i...n全部减掉size[x]

然后遍历到子节点时，如果父节点的预留没有被加回来，就把父节点预留的部分重新加回来size[fa]-1个(父节点自己要占一个)

其实这可以看成对树进行BFS的过程，要保证同一深度的节点都能取到最大值，所以有了“预留”这种操作来防止不同子树间的冲突

#include <cstdio>
#include <cstring>
#include <algorithm>
#define il inline
#define dd double
#define N 501000
using namespace std;
//re
int n,cte,cnt;dd K;
int a[N],org[N],lst[N],sz[N],head[N],ans[N],fa[N],add[N],id[N];
struct node{int id,val;}b[N];
struct Edge{int to,nxt;}edge[N];
void ae(int u,int v){
    cte++;edge[cte].to=v;
    edge[cte].nxt=head[u],head[u]=cte;
}
int cmp(int x,int y){return x>y;}
int cmp1(node x,node y){return x.val<y.val;}
int cmp2(node x,node y){return x.id<y.id;}
struct Seg{
    int mi[N<<2],tag[N<<2];
    il void pushup(int rt){mi[rt]=min(mi[rt<<1],mi[rt<<1|1]);}
    il void pushdown(int rt)
    {
        if(!tag[rt]) return;
        tag[rt<<1]+=tag[rt],tag[rt<<1|1]+=tag[rt];
        mi[rt<<1]+=tag[rt],mi[rt<<1|1]+=tag[rt];
        tag[rt]=0;
    }
    void build(int l,int r,int rt)
    {
        if(l==r){mi[rt]=l;return;}
        int mid=(l+r)>>1;
        build(l,mid,rt<<1);
        build(mid+1,r,rt<<1|1);
        pushup(rt);
    }
    void update(int L,int R,int l,int r,int rt,int w)
    {
        if(L<=l&&r<=R){mi[rt]+=w,tag[rt]+=w;return;}
        int mid=(l+r)>>1;
        pushdown(rt);
        if(L<=mid) update(L,R,l,mid,rt<<1,w);
        if(R>mid) update(L,R,mid+1,r,rt<<1|1,w);
        pushup(rt);
    }
    int find(int w,int l,int r,int rt)
    {
        if(l==r) return mi[rt]>=w?l:l+1;
        int mid=(l+r)>>1;
        pushdown(rt);
        if(mi[rt<<1|1]>=w) return find(w,l,mid,rt<<1);
        else return find(w,mid+1,r,rt<<1|1);
        pushup(rt);
    }
}seg;
int gint()
{
    int ret=0,fh=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=(ret<<3)+(ret<<1)+c-'0';c=getchar();}
    return ret*fh;
}
void dfs1(int u)
{
    for(int j=head[u];j;j=edge[j].nxt){
        int v=edge[j].to;
        dfs1(v);sz[u]+=sz[v];
    }sz[u]++;
}
void descrete()
{
    sort(b+1,b+n+1,cmp1);
    for(int i=1;i<=n;i++){
        if(b[i].val!=b[i-1].val)
            org[++cnt]=b[i].val;
        a[i]=cnt;
    }
}
void solve()
{
    for(int i=1;i<=n;i++)
    {
        if(fa[i]&&!add[fa[i]]) 
            seg.update(id[fa[i]],n,1,n,1,sz[fa[i]]-1),add[fa[i]]=1;
        int x=seg.find(sz[i],1,n,1);
        ans[i]=a[x],id[i]=x;
        seg.update(lst[ans[i]],n,1,n,1,-sz[i]);
        lst[ans[i]]--;
    }
}

int main()
{
    scanf("%d%lf",&n,&K);
    for(int i=1;i<=n;i++)
        b[i].val=gint(),b[i].id=i;
    descrete();
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++)
        lst[a[i]]=i;
    for(int i=n;i>=1;i--)
        fa[i]=(int)(1.0*i/K),ae(fa[i],i);
    dfs1(0);
    seg.build(1,n,1);
    solve();
    for(int i=1;i<=n;i++)
        printf("%d ",org[ans[i]]);
    puts("");
    return 0;
}