[NOIP2016]天天爱跑步

[NOIP2016]天天爱跑步

时间限制：2 s 内存限制：512 MB

题目描述

小C同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线，完成打卡任务。
这个游戏的地图可以看作一棵包含n个结点和n-1条边的树，每条边连接两个结点，且任意两个结点存在一条路径互相可达。树上结点编号为从1到n的连续正整数。
现在有m个玩家，第i个玩家的起点为Si，终点为Ti。每天打卡任务开始时，所有玩家在第0秒同时从自己的起点出发，以每秒跑一条边的速度，不间断地沿着最短路径向着自己的终点跑去，跑到终点后该玩家就算完成了打卡任务。（由于地图是一棵树，所以每个人的路径是唯一的）
小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。 在结点的观察员会选择在第Wj秒观察玩家, 一个玩家能被这个观察员观察到当且仅当该玩家在第Wj秒也理到达了结点J 。 小C想知道每个观察员会观察到多少人?
注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一 段时间后再被观察员观察到。 即对于把结点J作为终点的玩家: 若他在第Wj秒重到达终点,则在结点J的观察员不能观察到该玩家;若他正好在第Wj秒到达终点,则在结点的观察员可以观察到这个玩家。

输入格式

第一行有两个整数n和m。其中n代表树的结点数量，同时也是观察员的数量，m代表玩家的数量。
接下来n-1行每行两个整数u和v，表示结点u到结点v有一条边。
接下来一行n个整数，其中第j个整数为Wj，表示结点j出现观察员的时间。
接下来m行,每行两个整数Si和Ti，表示一个玩家的起点和终点。
对于所有的数据，保证1≤Si,Ti≤n，0≤ Wj ≤n。

输出格式

输出1行n个整数,第j个整数表示结点j的观察员可以观察到多少人。

样例1输入

6 3
2 3
1 2
1 4
4 5
4 6
0 2 5 1 2 3
1 5
1 3
2 6

样例1输出

2 0 0 1 1 1

样例2输入

5 3
1 2
2 3
2 4
1 5
0 1 0 3 0
3 1
1 4
5 5

样例2输出

1 2 1 0 1

提示

对于1号点，W1=0，故只有起点为1号点的玩家才会被观察到，所以玩家1和玩家2被观察到，共2人被观察到。
对于2号点，没有玩家在第2秒时在此结点，共0人被观察到。
对于3号点，没有玩家在第5秒时在此结点，共0人被观察到。
对于4号点，玩家1被观察到，共1人被观察到。
对于5号点，玩家2被观察到，共1人被观察到。
对于6号点，玩家3被观察到，共1人被观察到。

如果你的程序需要用到较大的栈空间(这通常意味着需要较深层数的递归)，请务必仔细阅读选手目录下的文档running/stackpdf，以了解在最终评测时栈空间的限制与在当前工作环境下调整栈空间限制的方法。

题解：

day1t2lca+差分。。。
先考虑链的情况：
很容易写出式子：deep[a]-deep[x]==w[x];
通过移项：deep[x]=w[x]+deep[x]。
可以发现，右边的式子是个定值。
那么转移到树上，可以分为三种情况
①.lca==a 从上沿着一条链往下。
②.lca==b 从下沿着一条链往上
③.lca！=a && lca！=b 这种情况可以分成上面两种，a到lca和lca到b。
a到lca：deep[a]-deep[lca]==w[lca]
lca到b：2*deep[lca]-deep[b]==w[lca]
在树上差分就可以了。
效率：mlogn 卡一卡可以过

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
using namespace std;

const int max_n = 300001;
const int inf = 1e6+7;
vector <int> add1[max_n],del1[max_n],add2[max_n],del2[max_n];

int point[max_n<<1],nxt[max_n<<1],v[max_n<<1];
int fa[max_n],top[max_n],deep[max_n],size[max_n],cnt[max_n*3];
int w[max_n],ans[max_n];
int n,m,a,b,tot;

inline void addedge(int x,int y)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x;
}

inline void init_tree()
{
    memset(nxt,-1,sizeof(nxt));
    memset(point,-1,sizeof(point));
    tot=-1;
}

inline void dfs1(int now,int f)
{
    fa[now]=f;
    deep[now]=deep[f]+1;
    size[now]=1;

    for(int i=point[now]; i!=-1; i=nxt[i])
      if(v[i]!=f)
      {
        dfs1(v[i],now);
        size[now]+=size[v[i]];
      }
}

inline void dfs2(int now,int tip)
{
    top[now]=tip;
    int mson=0;
    if(now!=1 && nxt[point[now]]==-1) return;
    for(int i=point[now]; i!=-1; i=nxt[i])
      if(size[v[i]]<size[now] && size[v[i]]>size[mson]) mson=v[i];
    dfs2(mson,tip);
    for(int i=point[now]; i!=-1; i=nxt[i])
      if(size[v[i]]<size[now] && v[i]!=mson) dfs2(v[i],v[i]);

}

inline int lca(int x,int y)
{
    while(top[x]!=top[y])
    {
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y]) swap(x,y);
    return x; 
}

inline void find_up(int now)
{
    ans[now]-=cnt[deep[now]-w[now]];
    for(int i=point[now]; i!=-1; i=nxt[i])
    {
        if(v[i]==fa[now]) continue;
        else find_up(v[i]);
    }
    for(int i=0; i<add1[now].size(); ++i)
      cnt[add1[now][i]]++;
    ans[now]+=cnt[deep[now]-w[now]];
    for(int i=0; i<del1[now].size(); ++i)
      cnt[del1[now][i]]--;
}

inline void find_down(int now)
{
    ans[now]-=cnt[deep[now]+w[now]];
    for(int i=point[now]; i!=-1; i=nxt[i])
    {
        if(v[i]==fa[now]) continue;
        else find_down(v[i]);
    }
    for(int i=0; i<add2[now].size(); ++i)
      cnt[add2[now][i]]++;
    ans[now]+=cnt[deep[now]+w[now]];
    for(int i=0; i<del2[now].size(); ++i)
      cnt[del2[now][i]]--;
}

int main()
{
    freopen("runninga.in","r",stdin);
    freopen("runninga.out","w",stdout);
    scanf("%d%d",&n,&m);
    init_tree();
    for(int i=1; i<n; ++i)
    {
        scanf("%d%d",&a,&b);
        addedge(a,b);
    }
    dfs1(1,0);
    dfs2(1,1);
    for(int i=1; i<=n; ++i)
    {
        scanf("%d",&w[i]);
        w[i]-=max_n;
    }
    for(int i=1; i<=m; ++i)
    {
        scanf("%d%d",&a,&b);
        int f=lca(a,b);
        if(f==b)
        {
            add2[a].push_back(deep[a]+max_n);
            del2[b].push_back(deep[a]+max_n);
        }
        else if(f==a)
        {
            add1[b].push_back(deep[a]+max_n);
            del1[a].push_back(deep[a]+max_n);
        }
        else 
        {
            add2[a].push_back(deep[a]+max_n);
            del2[f].push_back(deep[a]+max_n);
            add1[b].push_back(2*deep[f]-deep[a]+max_n);
            del1[f].push_back(2*deep[f]-deep[a]+max_n);
            if(deep[a]-deep[f]==w[f]+max_n)
              ans[f]--;
        }
    }
    find_up(1);
    for(int i=1; i<=n; ++i)
      w[i]+=2*max_n;
    find_down(1);
    for(int i=1; i<=n; ++i)
      printf("%d ",ans[i]);
    return 0;   
}