2020.4.25 集训总结

T1

P3605 [USACO17JAN]Promotion Counting P

当时脑子抽了写了个线段树合并…

不过这题是线段树合并板子题吧

#include 
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=1e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int n;
int a[N],b[N];
int head[N],cnt;
int m,tot;
int root[N];
int out[N];

struct Edge{
    int to,next;
}e[N<<1];

void add(int x,int y){
    e[++cnt]=(Edge){y,head[x]},head[x]=cnt;
}

struct node{
    int lc,rc;
    int val;
}seg[N<<5];

void update(int &u,int l,int r,int x,int k){
    if(!u)u=++tot;
    seg[u].val+=k;
    if(l==r)return;
    int mid=l+r>>1;
    if(x<=mid)update(seg[u].lc,l,mid,x,k);
    else update(seg[u].rc,mid+1,r,x,k);
}

int query(int &u,int l,int r,int ql,int qr){
    if(!u)return 0;
    if(l>=ql&&r<=qr)return seg[u].val;
    int mid=l+r>>1;
    int res=0;
    if(ql<=mid)res+=query(seg[u].lc,l,mid,ql,qr);
    if(qr>mid)res+=query(seg[u].rc,mid+1,r,ql,qr);
    return res;
}

int merge(int &u,int &v,int l,int r){
    if(!u||!v)return u|v;
    int o=++tot;
    if(l==r){
        seg[o].val=seg[u].val+seg[v].val;
        return o;
    }
    int mid=l+r>>1;
    seg[o].lc=merge(seg[u].lc,seg[v].lc,l,mid);
    seg[o].rc=merge(seg[u].rc,seg[v].rc,mid+1,r);
    seg[o].val=seg[seg[o].lc].val+seg[seg[o].rc].val;
    return o;
}

void dfs(int u){
    RepG(i,u){
        int v=e[i].to;
        dfs(v);
        root[u]=merge(root[u],root[v],1,m);
    }
    out[u]=query(root[u],1,m,a[u]+1,m);
    update(root[u],1,m,a[u],1);
}

int main()
{
    memset(head,-1,sizeof(head));
    read(n);
    Rep(i,1,n)read(a[i]),b[i]=a[i];
    sort(b+1,b+n+1);
    m=unique(b+1,b+n+1)-b-1;
    Rep(i,1,n)a[i]=lower_bound(b+1,b+m+1,a[i])-b;
    Rep(i,2,n){
        int x;
        read(x);
        add(x,i);
    }
    dfs(1);
    Rep(i,1,n)printf("%d\n",out[i]);
    return 0;
}

当然有更简单的做法
可以开一个权值线段树
我们在$dfs$到一个节点之后，首先算一下比他大的个数，然后向下$dfs$完了之后再算一遍，然后这两个之间的差就是子树中比他大的了

#include 
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=1e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int n;
int a[N],b[N];
int head[N],cnt;
int m,tot;
int root[N];
int out[N];

struct Edge{
    int to,next;
}e[N<<1];

void add(int x,int y){
    e[++cnt]=(Edge){y,head[x]},head[x]=cnt;
}

struct node{
    int lc,rc;
    int val;
}seg[N<<5];

void update(int &u,int l,int r,int x,int k){
    if(!u)u=++tot;
    seg[u].val+=k;
    if(l==r)return;
    int mid=l+r>>1;
    if(x<=mid)update(seg[u].lc,l,mid,x,k);
    else update(seg[u].rc,mid+1,r,x,k);
}

int query(int &u,int l,int r,int ql,int qr){
    if(!u)return 0;
    if(l>=ql&&r<=qr)return seg[u].val;
    int mid=l+r>>1;
    int res=0;
    if(ql<=mid)res+=query(seg[u].lc,l,mid,ql,qr);
    if(qr>mid)res+=query(seg[u].rc,mid+1,r,ql,qr);
    return res;
}

int merge(int &u,int &v,int l,int r){
    if(!u||!v)return u|v;
    int o=++tot;
    if(l==r){
        seg[o].val=seg[u].val+seg[v].val;
        return o;
    }
    int mid=l+r>>1;
    seg[o].lc=merge(seg[u].lc,seg[v].lc,l,mid);
    seg[o].rc=merge(seg[u].rc,seg[v].rc,mid+1,r);
    seg[o].val=seg[seg[o].lc].val+seg[seg[o].rc].val;
    return o;
}

void dfs(int u){
    RepG(i,u){
        int v=e[i].to;
        dfs(v);
        root[u]=merge(root[u],root[v],1,m);
    }
    out[u]=query(root[u],1,m,a[u]+1,m);
    update(root[u],1,m,a[u],1);
}

int main()
{
    memset(head,-1,sizeof(head));
    read(n);
    Rep(i,1,n)read(a[i]),b[i]=a[i];
    sort(b+1,b+n+1);
    m=unique(b+1,b+n+1)-b-1;
    Rep(i,1,n)a[i]=lower_bound(b+1,b+m+1,a[i])-b;
    Rep(i,2,n){
        int x;
        read(x);
        add(x,i);
    }
    dfs(1);
    Rep(i,1,n)printf("%d\n",out[i]);
    return 0;
}

T2

P1502 窗口的星星

考场上成功利用一个绝对错误的方法骗到了20分

我们考虑一个点会对哪一部分造成贡献，显然就是他右上角的一个矩形内

然后我们发现矩形内是没有意义的，我们可以把它放到边上

然后问题就转化成了一个类扫描线的问题，我们把每条边分成+1-1两种

然后问题就变成了区间加和区间求$\max$

#include 
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=1e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int t,n,w,h;
int x[N],y[N],l[N],b[N],sz;
int ans;

struct node{
    int max,tag;
}seg[N<<2];

struct scan{
    int x,y1,y2,val;
    bool operator < (const scan &cmp)const{
        if(x!=cmp.x)return x<cmp.x;
        return val>cmp.val;
    }
}a[N];

# define lc (u<<1)
# define rc (u<<1|1)

void pushup(int u){
    seg[u].max=max(seg[lc].max,seg[rc].max);
}

void pushdown(int u){
    seg[lc].max+=seg[u].tag;
    seg[lc].tag+=seg[u].tag;
    seg[rc].max+=seg[u].tag;
    seg[rc].tag+=seg[u].tag;
    seg[u].tag=0;
}

void update(int u,int l,int r,int ql,int qr,int k){
    if(l>=ql&&r<=qr){
        seg[u].max+=k;
        seg[u].tag+=k;
        return;
    }
    if(seg[u].tag)pushdown(u);
    int mid=l+r>>1;
    if(ql<=mid)update(lc,l,mid,ql,qr,k);
    if(qr>mid)update(rc,mid+1,r,ql,qr,k);
    pushup(u);
}

int main()
{
    read(t);
    while(t--){
        ans=0;
        for(int i=0;i<(N<<2);i++)seg[i].max=seg[i].tag=0;
        read(n),read(w),read(h);
        Rep(i,1,n)read(x[i]),read(y[i]),read(l[i]);
        Rep(i,1,n){
            a[i]=(scan){x[i],y[i],y[i]+h-1,l[i]};
            a[i+n]=(scan){x[i]+w-1,y[i],y[i]+h-1,-l[i]};
            b[i]=y[i];
            b[i+n]=a[i].y2;
            b[i+2*n]=a[i+n].y2;
        }
        sort(b+1,b+3*n+1);
        int sz=unique(b+1,b+3*n+1)-b-1;
        Rep(i,1,2*n){
            a[i].y1=lower_bound(b+1,b+sz+1,a[i].y1)-b;
            a[i].y2=lower_bound(b+1,b+sz+1,a[i].y2)-b;
        }
        sort(a+1,a+2*n+1);
        Rep(i,1,2*n){
            update(1,1,sz,a[i].y1,a[i].y2,a[i].val);
            ans=max(ans,seg[1].max);
        }
        printf("%d\n",ans);
    }
    return 0;
}

T3

P5324 [BJOI2019]删数

那么显然我们可以发现最后的答案和数字的顺序是无关的，所以我们可以考虑把所有的数降序排列

比如对于排序完的又一个这样的数列

10 10 10 7 7 7 7 3 3 3

我们发现这个序列显然是可以消掉的，先把10删掉，然后相应的7,3都会删掉

那如果我们把这个数列换一下，变成

10 10 10 6 6 6 6 3 3 3

那么这个东西就消不掉了

为什么呢？我们发现，当10全部被删掉之后，我们序列里还有7个数，但是我们需要删掉6，相当于中间空出来一个格子，那么这个时候我们就必须从后面拿一个补过来

从哪里拿呢？我们可以把一个3或者一个6变成7就可以

也就是说，对于一个数$i$有$cn{t}_i$个，那么全部的$i-cn{t}_i$一定是可以消掉的

如果没有$i-cn{t}_i$，我们就需要从后面拿一个过来

---

我们就可以把题目中的问题转化成一个类似于多米诺骨牌的模型

我们从最大的地方推倒，然后如果有空格，就从后面一个重复的地方拿一个缓过来

因为所有数的数量是相同的，这里空了一个后面一定还有一个

所以我们只需要完成区间加减和查询区间$0$的个数

对于区间$+1,-1$的操作，就是把区间进行了一下平移

---

但是这个东西怎么维护呢？我们发现我们要维护的东西和扫描线很像，在求面积并的时候我们就是维护了区间被覆盖过得长度

所以我们粘个代码交上去就好了

于是成功的拿到了$34$分的好成绩，为什么呢？

因为我们在维护扫描线的时候因为我们只需要求一个线段树整体的情况，也就是节点$1$处的答案，所以我们不需要考虑很多，更新的时候正常上传答案就可以

但是这里不同，我们需要查询一个区间的东西，但是我们当时是标记永久化掉的，显然不太好查询，所以我们需要换用另一种维护方法 大概只有我这么菜的才会这么想

我们维护三个量，$min$表示区间$0$的个数，$sum$表示最小值个个数，$cnt$表示$0$的个数，这样我们就很好进行更新了

---

再交上去，又WA了，为什么呢？

比如说$n=5$的时候，$a_i=\{1,3,3,4,5\}$，然后区间$+1$之后，$a_i=\{2,4,4,5,6\}$，这个时候我们发现，$6$是无论如何也推不倒的，因为我们只能从$n$开始推

所以我们不能把$[i-cn{t}_i+1,i],i>n$的区间算进去

怎么办呢？我们在区间左移右移的时候单独判断一下，如果他溢出了这个范围，就把这个区间整体删掉，如果他回来了，再加回来

相应的，我们在单点修改的时候也要考虑一下这种情况

然后就是代码了：

#include 
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=6e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int n,m;
int a[N],cnt[N];
int delta;

struct node{
    int l,r;
    int min,sum,cnt;//min,sum of min,cnt of 0
    int tag;
}seg[N<<2];

# define lc (u<<1)
# define rc (u<<1|1)

void pushup(int u){
    seg[u].min=min(seg[lc].min,seg[rc].min);
    seg[u].sum=seg[lc].sum*(seg[u].min==seg[lc].min)+seg[rc].sum*(seg[u].min==seg[rc].min);
    seg[u].cnt=seg[lc].cnt+seg[rc].cnt;
}

void renew(int u,int k){
    seg[u].min+=k;
    seg[u].cnt=(!seg[u].min)?seg[u].sum:0;
    seg[u].tag+=k;
}

void pushdown(int u){
    renew(lc,seg[u].tag);
    renew(rc,seg[u].tag);
    seg[u].tag=0;
}

void build(int u,int l,int r){
    seg[u].l=l,seg[u].r=r;
    if(l==r){
        seg[u].sum=seg[u].cnt=1;
        return;
    }
    int mid=l+r>>1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    pushup(u);
}

void update(int u,int l,int r,int k){
    if(l>r)return;
    if(seg[u].l>=l&&seg[u].r<=r){
        renew(u,k);
        return;
    }
    if(seg[u].tag)pushdown(u);
    int mid=seg[u].l+seg[u].r>>1;
    if(l<=mid)update(lc,l,r,k);
    if(r>mid)update(rc,l,r,k);
    pushup(u);
}

int query(int u,int l,int r){
    if(seg[u].l>=l&&seg[u].r<=r)return seg[u].cnt;
    if(seg[u].tag)pushdown(u);
    int mid=seg[u].l+seg[u].r>>1;
    int res=0;
    if(l<=mid)res+=query(lc,l,r);
    if(r>mid)res+=query(rc,l,r);
    return res;
}

int main()
{
    read(n),read(m);
    delta=200000;
    Rep(i,1,n)read(a[i]),a[i]+=delta,cnt[a[i]]++;
    build(1,1,6e5);
    Rep(i,delta+1,delta+n)update(1,i-cnt[i]+1,i,1);
    Rep(i,1,m){
        int p,x;
        read(p),read(x);
        if(!p){
            if(x>0){
                int pos=delta+n;
                update(1,pos-cnt[pos]+1,pos,-1);
                delta--;
            }
            else{
                delta++;
                int pos=delta+n;
                update(1,pos-cnt[pos]+1,pos,1);
            }
        }
        else{
            if(a[p]<=n+delta){
                update(1,a[p]-cnt[a[p]]+1,a[p],-1);
                cnt[a[p]]--;
                update(1,a[p]-cnt[a[p]]+1,a[p],1);
            }
            else cnt[a[p]]--;
            a[p]=delta+x;
            if(a[p]<=n+delta){
                update(1,a[p]-cnt[a[p]]+1,a[p],-1);
                cnt[a[p]]++;
                update(1,a[p]-cnt[a[p]]+1,a[p],1);
            }
            else cnt[a[p]]++;
        }
        printf("%d\n",query(1,delta+1,delta+n));
    }
    return 0;
}

T4/作业

P3437 [POI2006]TET-Tetris 3D

二维线段树/四分树/二分树/线段树套线段树板子题

这道题如果我们把操作看成区间覆盖就很难做

我们要看成区间取max和区间求max

为了保证复杂度以及不出一些奇奇怪怪的问题，我们考虑标记永久化

对于每一个节点开两个东西$max$和$tag$，其中$max$表示这个点的答案，$tag$表示这个点以及他下面的全部的答案

那么查询的时候就是完整包含区间的$max$和路径上的$tag$的$\max$

对于第二维，我们也相应的这么干就好了

其实可以不用动态开点，但是开始开了

#include 
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=1e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int d,s,n,tot;
int ans;
int mx[N],laz[N];

struct node{
    int lc,rc;
    int max,tag;
}seg[N<<6];

void updatecol(int &u,int l,int r,int ql,int qr,int k){
    if(!u)u=++tot;
    seg[u].max=max(seg[u].max,k);
    if(l>=ql&&r<=qr){
        seg[u].tag=max(seg[u].tag,k);
        return;
    }
    int mid=l+r>>1;
    if(ql<=mid)updatecol(seg[u].lc,l,mid,ql,qr,k);
    if(qr>mid)updatecol(seg[u].rc,mid+1,r,ql,qr,k);
}

void updaterow(int u,int l,int r,int qxl,int qxr,int qyl,int qyr,int k){
    updatecol(mx[u],0,s,qyl,qyr,k);
    if(l>=qxl&&r<=qxr){
        updatecol(laz[u],0,s,qyl,qyr,k);
        return;
    }
    int mid=l+r>>1;
    if(qxl<=mid)updaterow(u<<1,l,mid,qxl,qxr,qyl,qyr,k);
    if(qxr>mid)updaterow(u<<1|1,mid+1,r,qxl,qxr,qyl,qyr,k);
}

int querycol(int &u,int l,int r,int ql,int qr){
    if(!u)return 0;
    if(l>=ql&&r<=qr)return seg[u].max;
    int mid=l+r>>1;
    int res=seg[u].tag;
    if(ql<=mid)res=max(res,querycol(seg[u].lc,l,mid,ql,qr));
    if(qr>mid)res=max(res,querycol(seg[u].rc,mid+1,r,ql,qr));
    return res;
}

int queryrow(int u,int l,int r,int qxl,int qxr,int qyl,int qyr){
    if(l>=qxl&&r<=qxr)return querycol(mx[u],0,s,qyl,qyr);
    int mid=l+r>>1;
    int res=querycol(laz[u],0,s,qyl,qyr);
    if(qxl<=mid)res=max(res,queryrow(u<<1,l,mid,qxl,qxr,qyl,qyr));
    if(qxr>mid)res=max(res,queryrow(u<<1|1,mid+1,r,qxl,qxr,qyl,qyr));
    return res;
}

int main()
{
    read(d),read(s),read(n);
    Rep(i,1,n){
        int a,b,c,x,y;
        read(a),read(b),read(c),read(x),read(y);
        int h=queryrow(1,0,d,x,x+a-1,y,y+b-1);
        ans=max(ans,h+c);
        updaterow(1,0,d,x,x+a-1,y,y+b-1,h+c);
    }
    printf("%d\n",ans);
    return 0;
}