bzoj 3631 [JLOI2014]松鼠的新家

3631: [JLOI2014]松鼠的新家
Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 1885 Solved: 928
[Submit][Status][Discuss]
Description

松鼠的新家是一棵树，前几天刚刚装修了新家，新家有n个房间，并且有n-1根树枝连接，每个房间都可以相互到达，且俩个房间之间的路线都是唯一的。天哪，他居然真的住在“树”上。松鼠想邀请小熊维尼前来参观，并且还指定一份参观指南，他希望维尼能够按照他的指南顺序，先去a1，再去a2，……，最后到an，去参观新家。

可是这样会导致维尼重复走很多房间，懒惰的维尼不听地推辞。可是松鼠告诉他，每走到一个房间，他就可以从房间拿一块糖果吃。维尼是个馋家伙，立马就答应了。

现在松鼠希望知道为了保证维尼有糖果吃，他需要在每一个房间各放至少多少个糖果。因为松鼠参观指南上的最后一个房间an是餐厅，餐厅里他准备了丰盛的大餐，所以当维尼在参观的最后到达餐厅时就不需要再拿糖果吃了。

Input

第一行一个整数n，表示房间个数

第二行n个整数，依次描述a1-an

接下来n-1行，每行两个整数x，y，表示标号x和y的两个房间之间有树枝相连。

Output

一共n行，第i行输出标号为i的房间至少需要放多少个糖果，才能让维尼有糖果吃。

Sample Input

5

1 4 5 3 2

1 2

2 4

2 3

4 5

Sample Output

1

2

1

2

1

HINT

2<= n <=300000

---

【分析】
非常科学，也非常优雅的一道题
注意指向就好了
to[pos[i]]=num

---

【代码】

//JLOI 松鼠 
#include<cstdio>
#include<cstring>
#include<iostream>
#define ll long long
#define fo(i,j,k) for(i=j;i<=k;i++)
using namespace std;
const int mxn=300005;
int n,m,root,cnt,tot;
int pos[mxn],w[mxn],head[mxn],rlt[mxn];
struct edge {int to,next;} f[mxn<<1];
struct tree
{
    int fa,son,sz,dep,top,s,e;
}e[mxn];
struct lenth
{
    int l,r,sum,mark;
}t[mxn<<2];
inline 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;
}
inline void add(int u,int v)   //加边 
{
    f[++cnt].to=v,f[cnt].next=head[u],head[u]=cnt;
}
inline void dfs1(int u)    //第一次dfs 
{
    e[u].sz=1;
    for(int i=head[u];i;i=f[i].next)
    {
        int v=f[i].to;
        if(v==e[u].fa) continue;
        e[v].dep=e[u].dep+1;
        e[v].fa=u;
        dfs1(v);
        e[u].sz+=e[v].sz; 
        if(e[v].sz>e[e[u].son].sz)
          e[u].son=v;
    }
}
inline void dfs2(int u,int top)   //第二次dfs 
{
    e[u].top=top;
    e[u].s=++tot;
    pos[tot]=u;
    if(e[u].son)
    {
        dfs2(e[u].son,top);
        for(int i=head[u];i;i=f[i].next)
        {
            int v=f[i].to;
            if(v!=e[u].fa && v!=e[u].son)
              dfs2(v,v);
        }
    }
    e[u].e=tot;
}
inline void update(int num)   //线段树更新 
{
    t[num].sum=t[num<<1].sum+t[num<<1|1].sum;
}
inline void ope(int num,int c)
{
    t[num].sum+=(ll)(t[num].r-t[num].l+1)*c;
    t[num].mark+=c;
}
inline void pushdown(int num)
{
    if(t[num].mark)
    {
        if(t[num].l==t[num].r) return;
        ope(num<<1,t[num].mark);
        ope(num<<1|1,t[num].mark);
        t[num].mark=0;
    }
}
inline void build(int num,int l,int r)   //线段树build 
{
    t[num].l=l,t[num].r=r;
    if(l==r)
    {
        rlt[pos[l]]=num;
        return;
    }
    int mid=l+r>>1;
    build(num<<1,l,mid);
    build(num<<1|1,mid+1,r);
    update(num);
}
inline void ADD(int num,int L,int R,int c)  //线段树区间加 
{
    if(L<=t[num].l && t[num].r<=R)
    {
        t[num].mark+=c;
        t[num].sum+=(ll)(t[num].r-t[num].l+1)*c;
        return;
    }
    pushdown(num);
    if(L<=t[num<<1].r) ADD(num<<1,L,R,c);
    if(R>=t[num<<1|1].l) ADD(num<<1|1,L,R,c);
    update(num);
}
inline void add(int x,int y,int tmp)  //一条链上进行操作+
{
    int f1=e[x].top,f2=e[y].top;
    while(f1!=f2)
    {
        if(e[f1].dep<e[f2].dep)
          swap(f1,f2),swap(x,y);
        ADD(1,e[f1].s,e[x].s,tmp);
        x=e[f1].fa;
        f1=e[x].top;
    }
    if(e[x].dep<e[y].dep)
      ADD(1,e[x].s,e[y].s,tmp);
    else
      ADD(1,e[y].s,e[x].s,tmp);
}
inline void down(int num)
{
    if(t[num].l==t[num].r) return;
    pushdown(num);
    down(num<<1),down(num<<1|1);
}
int main()
{
    int i,j,u,v,x,y,c,opt,ttt=0;
    n=read();
    fo(i,1,n) w[i]=read(); 
    fo(i,2,n)
    {
        u=read(),v=read();
        add(u,v),add(v,u);
    }
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    fo(i,1,n-1)
    {
        int u=w[i],v=w[i+1];
        add(u,v,1);
        if(i!=1) ADD(1,e[u].s,e[u].s,-1);
        if(i==n-1) ADD(1,e[v].s,e[v].s,-1);
    }
    down(1);
    fo(j,1,n) printf("%d\n",t[rlt[j]].sum);
    return 0;
}
// 2 3 1 0 1
// 0 3 2 1 1