HDU5002:Tree(LCT)

Description

Input

Output

Sample Input

Sample Output

Solution

写了$6k$有点自闭……

一操作加边断边，二操作路径覆盖，三操作路径加，四操作求路径次大值和次大值个数。

记得讨论好覆盖标记和加标记的关系……再维护下最大值，最大值个数，次大值和次大值个数就好了。

码农题也没什么好说的……

Code

#include<iostream>
#include<cstring>
#include<cstdio>
#define N (100009)
#define INF (2000000000)
using namespace std;

int T,n,m,a,b,x,y,opt;
int Max1[N],Max2[N],Cnt1[N],Cnt2[N],Rev[N],Val[N];
int Father[N],Son[N][2],Add[N],Cov[N],Size[N];

inline int read()
{
    int x=0,w=1; char c=getchar();
    while (c<'0' || c>'9') {if (c=='-') w=-1; c=getchar();}
    while (c>='0' && c<='9') x=x*10+c-'0', c=getchar();
    return x*w;
}

int Get(int x)
{
    return Son[Father[x]][1]==x;
}

int Is_root(int x)
{
    return Son[Father[x]][0]!=x && Son[Father[x]][1]!=x;
}

void Pushup(int x)
{
    Size[x]=Size[Son[x][0]]+Size[Son[x][1]]+1;
    if (!Son[x][0] && !Son[x][1])
    {
        Max1[x]=Val[x]; Max2[x]=-INF;
        Cnt1[x]=1; Cnt2[x]=0;
        return;
    }
    if (!Son[x][1])
    {
        Max1[x]=Max1[Son[x][0]]; Max2[x]=Max2[Son[x][0]];
        Cnt1[x]=Cnt1[Son[x][0]]; Cnt2[x]=Cnt2[Son[x][0]];
    }
    else if (!Son[x][0])
    {
        Max1[x]=Max1[Son[x][1]]; Max2[x]=Max2[Son[x][1]];
        Cnt1[x]=Cnt1[Son[x][1]]; Cnt2[x]=Cnt2[Son[x][1]];
    }
    else if (Max1[Son[x][0]]==Max1[Son[x][1]])
    {
        Max1[x]=Max1[Son[x][0]];
        Cnt1[x]=Cnt1[Son[x][0]]+Cnt1[Son[x][1]];
        if (Max2[Son[x][0]]==Max2[Son[x][1]])
            Max2[x]=Max2[Son[x][0]], Cnt2[x]=Cnt2[Son[x][0]]+Cnt2[Son[x][1]];
        else if (Max2[Son[x][0]]>Max2[Son[x][1]])
            Max2[x]=Max2[Son[x][0]], Cnt2[x]=Cnt2[Son[x][0]];
        else Max2[x]=Max2[Son[x][1]], Cnt2[x]=Cnt2[Son[x][1]];
    }
    else if (Max1[Son[x][0]]>Max1[Son[x][1]])
    {
        Max1[x]=Max1[Son[x][0]];
        Cnt1[x]=Cnt1[Son[x][0]];
        if (Max2[Son[x][0]]==Max1[Son[x][1]])
            Max2[x]=Max2[Son[x][0]], Cnt2[x]=Cnt2[Son[x][0]]+Cnt1[Son[x][1]];
        else if (Max2[Son[x][0]]>Max1[Son[x][1]])
            Max2[x]=Max2[Son[x][0]], Cnt2[x]=Cnt2[Son[x][0]];
        else Max2[x]=Max1[Son[x][1]], Cnt2[x]=Cnt1[Son[x][1]];
    }
    else
    {
        Max1[x]=Max1[Son[x][1]];
        Cnt1[x]=Cnt1[Son[x][1]];
        if (Max1[Son[x][0]]==Max2[Son[x][1]])
            Max2[x]=Max1[Son[x][0]], Cnt2[x]=Cnt1[Son[x][0]]+Cnt2[Son[x][1]];
        else if (Max1[Son[x][0]]>Max2[Son[x][1]])
            Max2[x]=Max1[Son[x][0]], Cnt2[x]=Cnt1[Son[x][0]];
        else Max2[x]=Max2[Son[x][1]], Cnt2[x]=Cnt2[Son[x][1]];
    }
    if (Val[x]>Max1[x])
    {
        Cnt2[x]=Cnt1[x]; Max2[x]=Max1[x];
        Cnt1[x]=1; Max1[x]=Val[x];
    }
    else if (Val[x]==Max1[x]) Cnt1[x]++;
    else if (Val[x]>Max2[x]) Max2[x]=Val[x], Cnt2[x]=1;
    else if (Val[x]==Max2[x]) Cnt2[x]++;
}

void Pushdown(int x)
{
    if (Rev[x])
    {
        if (Son[x][0]) Rev[Son[x][0]]^=1;
        if (Son[x][1]) Rev[Son[x][1]]^=1;
        swap(Son[x][0],Son[x][1]);
        Rev[x]=0;
    }
    if (Add[x])
    {
        if (Son[x][0])
        {
            Val[Son[x][0]]+=Add[x];
            Add[Son[x][0]]+=Add[x];
            Max1[Son[x][0]]+=Add[x];
            if (Cov[Son[x][0]]!=INF) Cov[Son[x][0]]+=Add[x];
            if (Max2[Son[x][0]]!=-INF) Max2[Son[x][0]]+=Add[x];
        }
        if (Son[x][1])
        {
            Val[Son[x][1]]+=Add[x];
            Add[Son[x][1]]+=Add[x];
            Max1[Son[x][1]]+=Add[x];
            if (Cov[Son[x][1]]!=INF) Cov[Son[x][1]]+=Add[x];
            if (Max2[Son[x][1]]!=-INF) Max2[Son[x][1]]+=Add[x];
        }
        Add[x]=0;
    }
    if (Cov[x]!=INF)
    {
        if (Son[x][0])
        {
            Val[Son[x][0]]=Cov[x];
            Add[Son[x][0]]=0;
            Cov[Son[x][0]]=Cov[x];
            Max1[Son[x][0]]=Cov[x];
            Max2[Son[x][0]]=-INF;
            Cnt1[Son[x][0]]=Size[Son[x][0]];
            Cnt2[Son[x][0]]=0;
        }
        if (Son[x][1])
        {
            Val[Son[x][1]]=Cov[x];
            Add[Son[x][1]]=0;
            Cov[Son[x][1]]=Cov[x];
            Max1[Son[x][1]]=Cov[x];
            Max2[Son[x][1]]=-INF;
            Cnt1[Son[x][1]]=Size[Son[x][1]];
            Cnt2[Son[x][1]]=0;
        }
        Cov[x]=INF;
    }
}

void Rotate(int x)
{
    int wh=Get(x);
    int fa=Father[x],fafa=Father[fa];
    if (!Is_root(fa)) Son[fafa][Son[fafa][1]==fa]=x;
    Father[fa]=x; Son[fa][wh]=Son[x][wh^1];
    if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
    Father[x]=fafa; Son[x][wh^1]=fa;
    Pushup(fa); Pushup(x);
}

void Push(int x)
{
    if (!Is_root(x)) Push(Father[x]);
    Pushdown(x);
}

void Splay(int x)
{
    Push(x);
    for (int fa; !Is_root(x); Rotate(x))
        if (!Is_root(fa=Father[x]))
            Rotate(Get(fa)==Get(x)?fa:x);
}

void Access(int x)
{
    for (int y=0; x; y=x,x=Father[x])
        Splay(x), Son[x][1]=y, Pushup(x);
}

void Make_root(int x)
{
    Access(x); Splay(x);
    Rev[x]^=1;
}

int Find_root(int x)
{
    Access(x); Splay(x);
    while (Son[x][0]) x=Son[x][0];
    return x;
}

void Link(int x,int y)
{
    Make_root(x);
    Father[x]=y;
}

void Cut(int x,int y)
{
    Make_root(x);
    Access(y); Splay(y);
    Father[x]=Son[y][0]=0;
    Pushup(y);
}

void Clear()
{
    memset(Max1,0,sizeof(Max1));
    memset(Max2,0,sizeof(Max2));
    memset(Cnt1,0,sizeof(Cnt1));
    memset(Cnt2,0,sizeof(Cnt2));
    memset(Father,0,sizeof(Father));
    memset(Son,0,sizeof(Son));
    memset(Cov,0,sizeof(Cov));
    memset(Add,0,sizeof(Add));
    memset(Size,0,sizeof(Size));
}

int main()
{
    T=read();
    for (int t=1; t<=T; ++t)
    {
        Clear();
        n=read(); m=read();
        for (int i=1; i<=n; ++i)
        {
            Val[i]=read();
            Max1[i]=Val[i]; Cnt1[i]=1; Size[i]=1;
            Cov[i]=INF; Max2[i]=-INF;
        }
        for (int i=1; i<=n-1; ++i)
            x=read(), y=read(), Link(x,y);
        printf("Case #%d:
",t);
        for (int i=1; i<=m; ++i)
        {
            opt=read();
            if (opt==1)
            {
                x=read(); y=read(); a=read(); b=read();
                Cut(x,y); Link(a,b);
            }
            if (opt==2)
            {
                a=read(); b=read(); x=read();
                Make_root(a); Access(b); Splay(b);
                Cov[b]=x; Add[b]=0; Val[b]=x;
                Max2[b]=-INF; Cnt2[b]=0;
                Max1[b]=x; Cnt1[b]=Size[b];
            }
            if (opt==3)
            {
                a=read(); b=read(); x=read();
                Make_root(a);
                Access(b);
                Splay(b);
                Add[b]+=x; Val[b]+=x; Max1[b]+=x;
                if (Cov[b]!=INF) Cov[b]+=x;
                if (Max2[b]!=-INF) Max2[b]+=x;
            }
            if (opt==4)
            {
                a=read(); b=read();
                Make_root(a);
                Access(b);
                Splay(b);
                if (!Cnt2[b]) puts("ALL SAME");
                else printf("%d %d
",Max2[b],Cnt2[b]);
            }
        }
    }
}