1.【bzoj4034】[HAOI2015]T2

有一棵点数为 N 的树,以点 1 为根,且树点有边权。然后有 M 个

操作,分为三种:
操作 1 :把某个节点 x 的点权增加 a 。
操作 2 :把某个节点 x 为根的子树中所有点的点权都增加 a 。
操作 3 :询问某个节点 x 到根的路径中所有点的点权和。
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
#define inf 1000000000
#define mod 1000000000
using namespace std;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,cnt;
int last[100005];
int id,pos[100005],mx[100005],v[100005];
int bl[100005],size[100005],fa[100005];
ll tag[400005],sum[400005];
struct edge{
    int to,next;
}e[200005];
void insert(int u,int v)
{
    e[++cnt]=(edge){v,last[u]};last[u]=cnt;
    e[++cnt]=(edge){u,last[v]};last[v]=cnt;
}
void dfs(int x)
{
    size[x]=1;
    for(int i=last[x];i;i=e[i].next)
        if(e[i].to!=fa[x])
        {
            fa[e[i].to]=x;
            dfs(e[i].to);
            size[x]+=size[e[i].to];
            mx[x]=max(mx[x],mx[e[i].to]);
        }
}
void dfs2(int x,int cha)
{
    bl[x]=cha;pos[x]=mx[x]=++id;
    int k=0;
    for(int i=last[x];i;i=e[i].next)
        if(e[i].to!=fa[x]&&size[e[i].to]>size[k])
            k=e[i].to;
    if(k)
    {
        dfs2(k,cha);mx[x]=max(mx[x],mx[k]);
    }
    for(int i=last[x];i;i=e[i].next)
        if(e[i].to!=fa[x]&&e[i].to!=k)
        {
            dfs2(e[i].to,e[i].to);
            mx[x]=max(mx[x],mx[e[i].to]);
        }
}
void pushdown(int l,int r,int k)
{
    if(l==r)return;
    int mid=(l+r)>>1;ll t=tag[k];tag[k]=0;
    tag[k<<1]+=t;tag[k<<1|1]+=t;
    sum[k<<1]+=t*(mid-l+1);
    sum[k<<1|1]+=t*(r-mid);
}
void add(int k,int l,int r,int x,int y,ll val)
{
    if(tag[k])pushdown(l,r,k);
    if(l==x&&y==r){tag[k]+=val;sum[k]+=(r-l+1)*val;return;}
    int mid=(l+r)>>1;
    if(x<=mid)add(k<<1,l,mid,x,min(mid,y),val);
    if(y>=mid+1)add(k<<1|1,mid+1,r,max(mid+1,x),y,val);
    sum[k]=sum[k<<1]+sum[k<<1|1];
}
ll query(int k,int l,int r,int x,int y)
{
    if(tag[k])pushdown(l,r,k);
    if(l==x&&y==r)return sum[k];
    int mid=(l+r)>>1;
    ll ans=0;
    if(x<=mid)
        ans+=query(k<<1,l,mid,x,min(mid,y));
    if(y>=mid+1)
        ans+=query(k<<1|1,mid+1,r,max(mid+1,x),y);
    return ans;
}
ll query(int x)
{
    ll ans=0;
    while(bl[x]!=1)
    {
        ans+=query(1,1,n,pos[bl[x]],pos[x]);
        x=fa[bl[x]];
    }
    ans+=query(1,1,n,1,pos[x]);
    return ans;
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;i++)v[i]=read();
    for(int i=1;i<n;i++)
    {
        int u=read(),v=read();
        insert(u,v);
    }
    dfs(1);
    dfs2(1,1);
    for(int i=1;i<=n;i++)
        add(1,1,n,pos[i],pos[i],v[i]);
    int opt,x,a;
    while(m--)
    {
        opt=read();x=read();
        if(opt==1)
        {
            a=read();add(1,1,n,pos[x],pos[x],a);
        }
        if(opt==2)
        {
            a=read();add(1,1,n,pos[x],mx[x],a);
        }
        if(opt==3)printf("%lld\n",query(x));
    }
    return 0;
}
View Code

2.【bzoj2243】[SDOI2011]染色

给定一棵有n个节点的无根树和m个操作,操作有2类:

1、将节点a到节点b路径上所有点都染成颜色c;

2、询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”、“222”和“1”。

请你写一个程序依次完成这m个操作。

 

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#define N 100001
using namespace std;
int n,m,cnt,sz,head[N],deep[N],son[N],belong[N],pl[N],v[N],ft[N][18];
bool vis[N];
struct seg{int l,r,lc,rc,s,tag;}t[4*N];
struct edge{int to,next;}e[2*N];
void insert(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=head[u];head[u]=cnt;
    e[++cnt].to=u;e[cnt].next=head[v];head[v]=cnt;
}
void dfs1(int x)
{
    vis[x]=son[x]=1;
    for(int i=1;i<=17;i++)
    {
        if(deep[x]<(1<<i))break;
        ft[x][i]=ft[ft[x][i-1]][i-1];
    }
    for(int i=head[x];i;i=e[i].next)
    {
        if(vis[e[i].to])continue;
        deep[e[i].to]=deep[x]+1;
        ft[e[i].to][0]=x;
        dfs1(e[i].to);
        son[x]+=son[e[i].to];
    }
}
void dfs2(int x,int chain)
{
    pl[x]=++sz;belong[x]=chain;
    int k=0;
    for(int i=head[x];i;i=e[i].next)
        if(deep[e[i].to]>deep[x]&&son[k]<son[e[i].to])
           k=e[i].to;
    if(!k)return;
    dfs2(k,chain);
    for(int i=head[x];i;i=e[i].next)
        if(deep[e[i].to]>deep[x]&&k!=e[i].to)
           dfs2(e[i].to,e[i].to);
}
int lca(int x,int y)
{
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=17;i++)
       if(t&(1<<i))x=ft[x][i];
    for(int i=17;i>=0;i--)
       if(ft[x][i]!=ft[y][i])
       {x=ft[x][i];y=ft[y][i];}
    if(x==y)return x;
    return ft[x][0];
}
void build(int k,int l,int r)
{
    t[k].l=l;t[k].r=r;t[k].s=1;t[k].tag=-1;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);build(k<<1|1,mid+1,r);
}
void pushup(int k)
{
    t[k].lc=t[k<<1].lc;t[k].rc=t[k<<1|1].rc;
    if(t[k<<1].rc^t[k<<1|1].lc)t[k].s=t[k<<1].s+t[k<<1|1].s;
    else t[k].s=t[k<<1].s+t[k<<1|1].s-1;
}
void pushdown(int k)
{
    int tmp=t[k].tag;t[k].tag=-1;
    if(tmp==-1||t[k].l==t[k].r)return;
    t[k<<1].s=t[k<<1|1].s=1;
    t[k<<1].tag=t[k<<1|1].tag=tmp;
    t[k<<1].lc=t[k<<1].rc=tmp;
    t[k<<1|1].lc=t[k<<1|1].rc=tmp;
}
void change(int k,int x,int y,int c)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==x&&r==y)
    {t[k].lc=t[k].rc=c;t[k].s=1;t[k].tag=c;return;}
    int mid=(l+r)>>1;
    if(mid>=y)change(k<<1,x,y,c);
    else if(mid<x)change(k<<1|1,x,y,c);
    else
    {
        change(k<<1,x,mid,c);
        change(k<<1|1,mid+1,y,c);
    }
    pushup(k);
}
int ask(int k,int x,int y)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==x&&r==y)return t[k].s;
    int mid=(l+r)>>1;
    if(mid>=y)return ask(k<<1,x,y);
    else if(mid<x)return ask(k<<1|1,x,y);
    else
    {
        int tmp=1;
        if(t[k<<1].rc^t[k<<1|1].lc)tmp=0;
        return ask(k<<1,x,mid)+ask(k<<1|1,mid+1,y)-tmp;
    }
}
int getc(int k,int x)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==r)return t[k].lc;
    int mid=(l+r)>>1;
    if(x<=mid)return getc(k<<1,x);
    else return getc(k<<1|1,x);
}
int solvesum(int x,int f)
{
    int sum=0;
    while(belong[x]!=belong[f])
    {
        sum+=ask(1,pl[belong[x]],pl[x]);
        if(getc(1,pl[belong[x]])==getc(1,pl[ft[belong[x]][0]]))sum--;
        x=ft[belong[x]][0]; 
    }
    sum+=ask(1,pl[f],pl[x]);
    return sum;
}
void solvechange(int x,int f,int c)
{
    while(belong[x]!=belong[f])
    {
        change(1,pl[belong[x]],pl[x],c);
        x=ft[belong[x]][0]; 
    }
    change(1,pl[f],pl[x],c);
}
void solve()
{
    int a,b,c;
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    for(int i=1;i<=n;i++)
        change(1,pl[i],pl[i],v[i]);
    for(int i=1;i<=m;i++)
    {
        char ch[10];
        scanf("%s",ch);
        if(ch[0]=='Q')
        {
            scanf("%d%d",&a,&b);
            int t=lca(a,b);
            printf("%d\n",solvesum(a,t)+solvesum(b,t)-1);
        }
        else
        {
            scanf("%d%d%d",&a,&b,&c);
            int t=lca(a,b);
            solvechange(a,t,c);solvechange(b,t,c);
        }
    }
}
void ini()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&v[i]);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        insert(x,y);
    }
}
int main()
{
    ini();
    solve();
    return 0;
}
View Code

 

3.【bzoj1984】月下“毛景树”

Change k w:将第k条树枝上毛毛果的个数改变为w个。

Cover u v w:将节点u与节点v之间的树枝上毛毛果的个数都改变为w个。

Add u v w:将节点u与节点v之间的树枝上毛毛果的个数都增加w个。

Max u v:询问节点u与节点v之间树枝上毛毛果个数最多有多少个。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 100001
#define inf 0x7fffffff
using namespace std;
int n,cnt=1,sz;
int head[N],deep[N],size[N],pos[N],belong[N];
int fa[N][17],id[N];
struct edge{int to,next,v;}e[N<<1];
struct seg{int l,r,mx,a,c;}t[N<<2];
void insert(int u,int v,int w)
{
    e[++cnt].to=v;e[cnt].next=head[u];e[cnt].v=w;head[u]=cnt;
    e[++cnt].to=u;e[cnt].next=head[v];e[cnt].v=w;head[v]=cnt;
}
int lca(int x,int y)
{
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=16;i++)
       if(t&(1<<i))x=fa[x][i];
    for(int i=16;i>=0;i--)
       if(fa[x][i]!=fa[y][i])
       {x=fa[x][i];y=fa[y][i];}
    if(x==y)return x;
    return fa[x][0];
}
void pushdown(int k)
{
    if(t[k].l==t[k].r)return;
    if(t[k].c!=-1)
    {
        t[k<<1].a=t[k<<1|1].a=0;
        t[k<<1].c=t[k<<1|1].c=t[k].c;
        t[k<<1].mx=t[k<<1|1].mx=t[k].c;
        t[k].c=-1;
    }
    if(t[k].a)
    {
        t[k<<1].mx+=t[k].a;t[k<<1|1].mx+=t[k].a;
        if(t[k<<1].c!=-1)t[k<<1].c+=t[k].a;
        else t[k<<1].a+=t[k].a;
        if(t[k<<1|1].c!=-1)t[k<<1|1].c+=t[k].a;
        else t[k<<1|1].a+=t[k].a;
        t[k].a=0;
    }
}
void build(int k,int l,int r)
{
    t[k].l=l;t[k].r=r;t[k].c=-1;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);build(k<<1|1,mid+1,r);
}
void pushup(int k)
{t[k].mx=max(t[k<<1].mx,t[k<<1|1].mx);}
void change(int k,int x,int y,int v)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==x&&y==r){t[k].mx=t[k].c=v;return;}
    int mid=(l+r)>>1;
    if(mid>=y)change(k<<1,x,y,v);
    else if(mid<x)change(k<<1|1,x,y,v);
    else 
    {
        change(k<<1,x,mid,v);
        change(k<<1|1,mid+1,y,v);
    }
    pushup(k);
}
void add(int k,int x,int y,int v)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==x&&y==r){t[k].mx+=v;t[k].a=v;return;}
    int mid=(l+r)>>1;
    if(mid>=y)add(k<<1,x,y,v);
    else if(mid<x)add(k<<1|1,x,y,v);
    else 
    {
        add(k<<1,x,mid,v);
        add(k<<1|1,mid+1,y,v);
    }
    pushup(k);
}
int ask(int k,int x,int y)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r;
    if(l==x&&y==r)return t[k].mx;
    int mid=(l+r)>>1;
    if(mid>=y)return ask(k<<1,x,y);
    else if(mid<x)return ask(k<<1|1,x,y);
    else return max(ask(k<<1,x,mid),ask(k<<1|1,mid+1,y));
}
void solvechange(int x,int f,int v)
{
    while(belong[x]!=belong[f])
    {
        change(1,pos[belong[x]],pos[x],v);
        x=fa[belong[x]][0]; 
    }
    if(pos[f]+1<=pos[x])
    change(1,pos[f]+1,pos[x],v);
}
void solveadd(int x,int f,int v)
{
    while(belong[x]!=belong[f])
    {
        add(1,pos[belong[x]],pos[x],v);
        x=fa[belong[x]][0]; 
    }
    if(pos[f]+1<=pos[x])
    add(1,pos[f]+1,pos[x],v);
}
int solveask(int x,int f)
{
    int mx=-inf;
    while(belong[x]!=belong[f])
    {
        mx=max(mx,ask(1,pos[belong[x]],pos[x]));
        x=fa[belong[x]][0]; 
    }
    if(pos[f]+1<=pos[x])
        mx=max(mx,ask(1,pos[f]+1,pos[x]));
    return mx;
}
void solve()
{
    char s[10];
    int u,v,w,f;
    while(1)
    {
        scanf("%s",s);
        switch(s[1])
        {
            case 't':return;break;
            case 'd':scanf("%d%d%d",&u,&v,&w);f=lca(u,v);
                     solveadd(u,f,w);solveadd(v,f,w);break;
            case 'o':scanf("%d%d%d",&u,&v,&w);f=lca(u,v);
                     solvechange(u,f,w);solvechange(v,f,w);
                     break;
            case 'h':scanf("%d%d",&u,&w);change(1,pos[id[u]],pos[id[u]],w);break;
            case 'a':scanf("%d%d",&u,&v);f=lca(u,v);
                     printf("%d\n",max(solveask(u,f),solveask(v,f)));
                     break;
        }
    }
}
void dfs1(int x,int f)
{
    size[x]=1;
    for(int i=1;i<=16;i++)
        if((1<<i)<=deep[x])
            fa[x][i]=fa[fa[x][i-1]][i-1];
        else break;
    for(int i=head[x];i;i=e[i].next)
    {
        if(e[i].to==f)continue;
        deep[e[i].to]=deep[x]+1;
        fa[e[i].to][0]=x;
        dfs1(e[i].to,x);
        size[x]+=size[e[i].to];
    }
}
void dfs2(int x,int chain)
{
    belong[x]=chain;
    pos[x]=++sz;
    int k=0;
    for(int i=head[x];i;i=e[i].next)
    {
       if(deep[x]<deep[e[i].to])
       {
           if(size[e[i].to]>size[k])k=e[i].to;
       }
       else {id[i>>1]=x;add(1,pos[x],pos[x],e[i].v);}
    }
    if(!k)return;
    dfs2(k,chain);
    for(int i=head[x];i;i=e[i].next)
        if(deep[x]<deep[e[i].to]&&k!=e[i].to)
            dfs2(e[i].to,e[i].to);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n-1;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        insert(u,v,w);
    }
    build(1,1,n);
    dfs1(1,0);
    dfs2(1,1);
    solve();
    return 0;
}
View Code

相关文章: