2020.4.25 集訓總結

T1

P3605 [USACO17JAN]Promotion Counting P

當時腦子抽了寫了個線段樹合併…

~~不過這題是線段樹合併板子題吧~~

#include <bits/stdc++.h>
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 <bits/stdc++.h>
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 <bits/stdc++.h>
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$ 有 $cnt_i$ 個，那麼全部的 $i-cnt_i$ 一定是可以消掉的

如果沒有 $i-cnt_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-cnt_i+1,i],i>n$ 的區間算進去

怎麼辦呢？我們在區間左移右移的時候單獨判斷一下，如果他溢出了這個範圍，就把這個區間整體刪掉，如果他回來了，再加回來

相應的，我們在單點修改的時候也要考慮一下這種情況

然後就是代碼了：

#include <bits/stdc++.h>
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 <bits/stdc++.h>
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;
}

2020.4.25 集訓總結

T1

T2

T3

T4/作業

AtCoder ABC169

[THUPC2019] 不等式

期望基本概念和性質

[vijos1477] 跳動的水珠

[BJOI2014] 大融合

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結