bzoj千题计划243：bzoj2325: [ZJOI2011]道馆之战

http://www.lydsy.com/JudgeOnline/problem.php?id=2325

设线段树节点区间为[l,r]

每个节点维护sum[0/1][0/1]  从l的A/B区域到r的A/B区域 经过冰块的最大数量

mx[0][0] 从l的A区域出发向r经过冰块的最大数量

mx[0][1] 从l的B区域出发向r经过冰块的最大数量

mx[1][0] 从r的A区域出发向l经过冰块的最大数量

mx[1][1] 从r的B区域出发向l经过冰块的最大数量

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

#define N 30001

using namespace std;

int n;

int front[N],nxt[N<<],to[N<<],tot;

int fa[N],dep[N],siz[N];
int bl[N];

int id[N],dy[N],cnt;

bool a[N][];

#define max(x,y) ((x)>(y) ? (x) : (y))

struct node
{
    int sum[][];
    int mx[][];

    node()
    {
        for(int i=;i<;++i)
            for(int j=;j<;++j)
                sum[i][j]=mx[i][j]=;
    } 

    node operator + (node p) const
    {
        node k;
        for(int i=;i<=;++i)
            for(int j=;j<=;++j)
            {
                if(sum[i][] && p.sum[][j])
                k.sum[i][j]=max(k.sum[i][j],sum[i][]+p.sum[][j]);
                if(sum[i][] && p.sum[][j])
                k.sum[i][j]=max(k.sum[i][j],sum[i][]+p.sum[][j]);
            }
        k.mx[][]=max(k.sum[][],k.sum[][]);
        k.mx[][]=max(k.sum[][],k.sum[][]);
        k.mx[][]=max(k.sum[][],k.sum[][]);
        k.mx[][]=max(k.sum[][],k.sum[][]);
        if(sum[][]) k.mx[][]=max(k.mx[][],sum[][]+p.mx[][]);
        if(sum[][]) k.mx[][]=max(k.mx[][],sum[][]+p.mx[][]);
        if(sum[][]) k.mx[][]=max(k.mx[][],sum[][]+p.mx[][]);
        if(sum[][]) k.mx[][]=max(k.mx[][],sum[][]+p.mx[][]);
        if(p.sum[][]) k.mx[][]=max(k.mx[][],mx[][]+p.sum[][]);
        if(p.sum[][]) k.mx[][]=max(k.mx[][],mx[][]+p.sum[][]);
        if(p.sum[][]) k.mx[][]=max(k.mx[][],mx[][]+p.sum[][]);
        if(p.sum[][]) k.mx[][]=max(k.mx[][],mx[][]+p.sum[][]);
        k.mx[][]=max(k.mx[][],mx[][]);
        k.mx[][]=max(k.mx[][],mx[][]);
        k.mx[][]=max(k.mx[][],p.mx[][]);
        k.mx[][]=max(k.mx[][],p.mx[][]);
        return k;
    }

    void turn()
    {
        swap(sum[][],sum[][]);
        swap(mx[][],mx[][]);
        swap(mx[][],mx[][]);
    }

}tr[N<<];

void read(int &x)
{
    x=; char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) { x=x*+c-''; c=getchar(); }
}

void add(int u,int v)
{
    to[++tot]=v; nxt[tot]=front[u]; front[u]=tot;
    to[++tot]=u; nxt[tot]=front[v]; front[v]=tot;
}

void dfs1(int x)
{
    siz[x]=;
    for(int i=front[x];i;i=nxt[i])
        if(to[i]!=fa[x])
        {
            fa[to[i]]=x;
            dep[to[i]]=dep[x]+;
            dfs1(to[i]);
            siz[x]+=siz[to[i]];
        }
}

void dfs2(int x,int top)
{
    bl[x]=top;
    id[x]=++cnt;
    dy[cnt]=x;
    int y=;
    for(int i=front[x];i;i=nxt[i])
        if(to[i]!=fa[x] && siz[to[i]]>siz[y]) y=to[i];
    if(y) dfs2(y,top);
    else return;
    for(int i=front[x];i;i=nxt[i])
        if(to[i]!=y && to[i]!=fa[x]) dfs2(to[i],to[i]);
}

void build(int k,int l,int r)
{
    if(l==r)
    {
        if(a[dy[l]][]) tr[k].sum[][]=;
        if(a[dy[l]][]) tr[k].sum[][]=;
        if(a[dy[l]][] && a[dy[l]][]) tr[k].sum[][]=tr[k].sum[][]=;
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        return;
    }
    int mid=l+r>>;
    build(k<<,l,mid);
    build(k<<|,mid+,r);
    tr[k]=tr[k<<]+tr[k<<|];
}

node query(int k,int l,int r,int opl,int opr)
{
    if(l>=opl && r<=opr) return tr[k];
    int mid=l+r>>;
    if(opr<=mid) return query(k<<,l,mid,opl,opr);
    else if(opl>mid) return query(k<<|,mid+,r,opl,opr);
    else return query(k<<,l,mid,opl,opr)+query(k<<|,mid+,r,opl,opr);
}

void Query(int u,int v)
{
    node ansu,ansv;
    bool firstu=false,firstv=false;
    while(bl[u]!=bl[v])
    {
        if(dep[bl[u]]>dep[bl[v]])
        {
            if(!firstu) firstu=true,ansu=query(,,n,id[bl[u]],id[u]);
            else ansu=query(,,n,id[bl[u]],id[u])+ansu;
            u=fa[bl[u]];
        }
        else
        {
            if(!firstv) firstv=true,ansv=query(,,n,id[bl[v]],id[v]);
            else ansv=query(,,n,id[bl[v]],id[v])+ansv;
            v=fa[bl[v]];
        }
    }
    if(dep[u]>dep[v])
    {
        if(!firstu) firstu=true,ansu=query(,,n,id[v],id[u]);
        else ansu=query(,,n,id[v],id[u])+ansu;
    }
    else
    {
        if(!firstv) firstv=true,ansv=query(,,n,id[u],id[v]);
        else ansv=query(,,n,id[u],id[v])+ansv;
    }
    if(!firstu) ansu=ansv;
    else
    {
        ansu.turn();
        if(firstv) ansu=ansu+ansv;
    }
    cout<<max(ansu.mx[][],ansu.mx[][])<<'\n';
}

void change(int k,int l,int r,int x,bool u,bool v)
{
    if(l==r)
    {
        a[l][]=u;
        a[l][]=v;
        if(a[l][]) tr[k].sum[][]=;
        else tr[k].sum[][]=;
        if(a[l][]) tr[k].sum[][]=;
        else tr[k].sum[][]=;
        if(a[l][] && a[l][]) tr[k].sum[][]=tr[k].sum[][]=;
        else tr[k].sum[][]=tr[k].sum[][]=;
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        tr[k].mx[][]=max(tr[k].sum[][],tr[k].sum[][]);
        return;
    }
    int mid=l+r>>;
    if(x<=mid) change(k<<,l,mid,x,u,v);
    else change(k<<|,mid+,r,x,u,v);
    tr[k]=tr[k<<]+tr[k<<|];
}

int main()
{
    freopen("fight.in","r",stdin);
    freopen("fight.out","w",stdout);
    int m;
    read(n); read(m);
    int u,v;
    for(int i=;i<n;++i)
    {
        read(u); read(v);
        add(u,v);
    }
    dfs1();
    dfs2(,);
    char s[];
    for(int i=;i<=n;++i)
    {
        scanf("%s",s);
        if(s[]=='.') a[i][]=true;
        if(s[]=='.') a[i][]=true;
    }
    build(,,n);
    char c[];
    while(m--)
    {
        scanf("%s",c);
        if(c[]=='Q')
        {
            read(u); read(v);
            Query(u,v);
        }
        else
        {
            read(u);
            scanf("%s",c);
            change(,,n,id[u],c[]=='.',c[]=='.');
        }
    }
}