Codeforces Round #381 (Div. 1) B. Alyona and a tree 树+二分+前缀和+dfs / dfs序+树状数组

题目链接：

http://codeforces.com/contest/739/problem/B

题意：

一颗树1~n，以1为根节点，每个节点i都有一个对应的a[i]值，每条边有一个边权，问每个节点可以控制多少个子节点 并输出
控制的定义：dis(u,v)<=a[v]  u是v的祖先
dis(u,v)的定义：从u到v的边上的权值之和

思路：

二分，前缀和，dfs的思想： http://www.cnblogs.com/s1124yy/p/6103184.html

dfs序，树状数组的思想： http://blog.csdn.net/survivorone/article/details/53332726

都非常机智啊...

如何处理dis(u,v)<=a[v]咧，跑一遍dfs，处理出depth[i]表示i这个点到达根节点1的边权和，那么 depth[v]-depth[u]<=a[v] ----> depth[v]-a[v]<=depth[u]。 

第一种做法： 大致思想是比如dfs到当前的节点u，我们记录了dfs出的这条链的路径的边权和以及点，所以用这条链的边权和，二分出当前点的祖先不合法的最近的那个点，更新答案，使他减1，不合法就是depth[祖先]<depth[当前]-a[当前]的最低点。总之一句话: 把当前点对不合法的最近祖先的贡献删掉。

下面是复制的：

dfs扫一遍，depth[]存的是权值前缀和，前缀和存在单调性，这时就可以想到用二分了。（构造前缀和，以便用二分）

--1---
-2-3--
--4-5-

上面是样例的树，假如我dfs到了第4个节点，那么我就二分4 3 1这个路径的前缀和，找到能控制4的最大区间，更新这个区间，之后继续dfs第5个节点，这时修改前缀和的数组，也就是path数组，把 4 pop_back掉，把 5 push进去，这就可以二分5 3 1这条路了。

第二种做法：

1、dfs 求出每一个点距离树根的距离 depth[N]，用时间戳 in[N],out[N]数组记录进出点的时间并将子节点的时间戳包含在父亲节点的时间戳之内；

2、对于每一个点，值为a[N]，处理出 node(1,i,depth[i]-a[i]) 与 node(2,i,depth[i]); 两组数据，并按第3个值升序排序； [类型1是更新树状数组的，通过类型2查询比depth[i]小的有多少，就是答案啦，因为按照第3个值排序了，所以后面大的值不可能影响答案，那么如何查询一个子树对答案的贡献呢，dfs序啊，树状数组就是处理的dfs序，dfs序一颗子树一定在一段连续的标号上，所以就是 get(in[u])-get(out[u]),因为u不能算作贡献，自己不能控制自己嘛]

3、再维护一个树状数组更新、求和即可。

总结:

感觉第一种方法是把一颗树上的一条链上的信息维护起来，为后面二分找到不合法祖先做准备, 可能叫树链剖分?太菜，还没接触过树剖

第二种方法是用dfs序把树压成一条直线处理的。

代码：

代码一：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MS(a) memset(a,0,sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read(){
    ll 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;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 2e5+10;

int n;
ll a[maxn];
vector<pair<ll,ll> > g[maxn];
vector<pair<ll,int> > path;
ll ans[maxn],depth[maxn];

void dfs(ll u,int fa){
    ans[u] = 1;
    int idx = lower_bound(path.begin(),path.end(),MP(depth[u]-a[u],-1)) - path.begin();
    idx--;
    if(idx >= 0) ans[path[idx].second]--;
    path.push_back(MP(depth[u],u));
    for(int i=0; i<(int)g[u].size(); i++){
        ll v = g[u][i].first, w = g[u][i].second;
        if(v == fa) continue;
        depth[v] = depth[u]+w;
        dfs(v,u);
        ans[u] += ans[v];
    }
    path.pop_back();
}

int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        cin >> a[i];
    for(int i=2; i<=n; i++){
        int to,w; cin>>to>>w;
        g[i].push_back(MP(to,w));
        g[to].push_back(MP(i,w));
    }

    dfs(1,-1);

    for(int i=1; i<=n; i++)
        cout << ans[i]-1 << " ";
    puts("");

    return 0;
}

代码二：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MS(a) memset(a,0,sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read(){
    ll 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;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 2e5+10;

int n;
vector<pair<ll,ll> > g[maxn];
ll a[maxn],tot,depth[maxn],ans[maxn],bit[maxn*4],in[maxn],out[maxn];

void dfs(int u,int fa){
    in[u] = ++tot;
    for(int i=0; i<(int)g[u].size(); i++){
        ll v = g[u][i].first,w = g[u][i].second;
        if(v == fa) continue;
        depth[v] = depth[u]+w;
        dfs(v,u);
    }
    out[u] = tot;
}

struct node{
    ll type,u,sum;
    node(){}
    node(ll x,ll y,ll z){
        type = x; u = y; sum = z;
    }
}k[maxn*2];

bool cmp(node A,node B){
    if(A.sum == B.sum) return A.type<B.type;
    return A.sum<B.sum;
}

void add(int x){
    while(x < maxn*4){
        bit[x]++;
        x += x&-x;
    }
}

ll get(int x){
    ll res = 0;
    while(x > 0){
        res += bit[x];
        x -= x&-x;
    }
    return res;
}

int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        a[i]=read();
    for(int i=2; i<=n; i++){
        ll to,w; scanf("%I64d%I64d",&to,&w);
        g[i].push_back(MP(to,w));
        g[to].push_back(MP(i,w));
    }
    dfs(1,-1);
    int cnt = 1;
    for(int i=1; i<=n; i++){
        k[cnt++] = node{1,i,depth[i]-a[i]};
        k[cnt++] = node{2,i,depth[i]};
    }
    sort(k+1,k+cnt,cmp);
    for(int i=1; i<cnt; i++){
        if(k[i].type == 1){
            add(in[k[i].u]);
        }else{
            ans[k[i].u] = get(out[k[i].u]) - get(in[k[i].u]);
        }
    }
    for(int i=1; i<=n; i++){
        cout << ans[i] << " ";
    }
    puts("");

    return 0;
}