BZOJ 3631: [JLOI2014]松鼠的新家

   太好了，第一次交就AC了，第一次这么顺利，这是一道树链剖分的题，比较容易吧！加油，相信自己，能行的。

  不过还是有点慢，跑了1900多毫秒。

#include<cstdio>
#include<iostream>
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 300005
using namespace std;
int shun[maxn];
 
struct node{
int addv, l, r;
node() {
   addv = l = r = 0;
}
} nod[maxn*4];
 
struct edge{
int to;
edge* next;
};
edge *head[maxn], edges[maxn*2], *pt; 
 
void add_edge(int x,int y)
{
    pt->to = x, pt->next = head[y], head[y] = pt++;
    pt->to = y, pt->next = head[x], head[x] = pt++;
}
 
int read()
{
    int s = 0, t = 1; char c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c - '0'; c = getchar();
    }
    return s * t;
}
int pa[maxn], top[maxn], dep[maxn], size[maxn], son[maxn];
int w[maxn], tot = 0;
 
void dfs(int now)
{
    size[now] = 1, son[now] = 0;
    for(edge* i = head[now]; i; i = i->next){
        int to = i->to; if( to == pa[now] ) continue;
        pa[to] = now, dep[to] = dep[now] + 1;
        dfs(to); size[now] += size[to];
        if( size[to] > size[son[now]] ) son[now] = to;
    }
}
 
void dfs2(int now,int ph)
{
    top[now] = ph, w[now] = ++tot;
    if( son[now] ) dfs2(son[now],ph);
    for(edge*i = head[now]; i; i = i->next){
        int to = i->to; if( to == pa[now] || to == son[now] ) continue;
        dfs2(to,to);
    } 
} 
 
void yuchu(int l,int r,int num)
{
    nod[num].l = l, nod[num].r = r;
    if( l == r ){
        if( w[shun[1]] != l ) nod[num].addv = -1;
        return;
    }
    int mid = (l+r) / 2;
    yuchu(l,mid,num*2);
    yuchu(mid+1,r,num*2+1);
}
 
void update(int l,int r,int num)
{
    int ll = nod[num].l, rr = nod[num].r;
    if( ll >= l && r >= rr ){
        nod[num].addv += 1;
        return ;
    }
    int mid = (ll+rr) / 2;
    if( r <= mid ) update(l,r,num*2);
    else if( l > mid ) update(l,r,num*2+1);
    else update(l,mid,num*2), update(mid+1,r,num*2+1);
}
 
void add(int x,int y)
{
    while( top[x] != top[y] ){
        if( dep[top[x]] < dep[top[y]] ){
            swap(x,y);
        }
        update(w[top[x]],w[x],1);
        x = pa[top[x]];
    }
    if( dep[x] > dep[y] ) swap(x,y);
    update(w[x],w[y],1);
}
 
void main_tain(int num)
{
    if( !nod[num].addv ) return;
    nod[num*2].addv += nod[num].addv;
    nod[num*2+1].addv += nod[num].addv;
}
 
void push(int num)
{
    int l = nod[num].l, r = nod[num].r;
    if( l == r ) {
        w[shun[l]] = nod[num].addv;
        return;
    }
    main_tain(num);
    push(num*2), push(num*2+1);
}
 
int main()
{
    int n = read();
    rep(i,1,n) shun[i] = read();
    pt = edges;
    rep(i,1,n-1){
        int x = read(), y = read();
        add_edge(x,y);
    }
    dep[1] = 1;
    dfs(1);
    dfs2(1,1);
    yuchu(1,tot,1);
    rep(i,2,n){
        add(shun[i-1],shun[i]);
    }
    rep(i,1,n) shun[w[i]] = i;
    push(1);
    rep(i,1,n){
        printf("%d
", w[i]);
    }
    return 0;
}

3631: [JLOI2014]松鼠的新家

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 991  Solved: 489
[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