LibreOJ#2359天天爱跑步

天天爱跑步

这或许现在不是(NOIP)最毒瘤的题了叭.
(当然你说是,我还可以肛你说(NOIP)没了)

嗯...一个很显然的暴力思路是:
对于每一个玩家,暴力跟着跑,走到(w_i)等于当前时间的点就统计.
这显然是对的...但它太慢了,完全跑不过去.

我们发现题目里给的条件其实是个这个:
设一条路径的起点终点分别是(s_i,t_i),长度是(dis_{i,j}),(LCA)是(lca_{i,j}),某一点(x)是(deep_x).

[dis(s_i,t_i)-deep_{t_i}=w_p-deep_p ]

和

[deep_s=deep_p+w_p ]

然后我们的问题就变成了对于每一个点,求它的子树内有多少点的权值和它相等,当然,权值有两种.
然后...这个很难做对叭.
我们想怎么去做它,因为我们发现这是不可避免的.
这时候大佬可能会说了,直接线段树维护桶,线段树合并即可.
但这不是我们要说的.(拒绝大力数据结构,偶尔写写还是挺开心的
我们的做法也是维护桶,但并非这么暴力,这种维护方法非常优美.
用桶去维护权值,下标就是权值,存储的值是有多少个.
我们发现,直接去维护这个全局桶是显然没法做的.
我们考虑,枚举观察点,去它的子树里统计.
由于观察点是所有点,所以我们只需要一遍(dfs)去枚举即可.
而(dfs)由于其优美的特性,恰好能完成对子树的统计.
这样可以发现,统计答案部分的复杂度是(Theta(n))的,也就是说这题的复杂度瓶颈在于(LCA).
考虑如何统计:
对每一种权值,显然直接统计即可.
但当我们回溯的时候,我们发现,这时候,以当前点(x)为(LCA)的所有点都已经没有了贡献,所以我们需要把这一部分的贡献减去.
于是我们需要维护一个链表,维护以(x)为(LCA)的路径信息.
每次回溯的时候,遍历这个链表,把所有的以当前点为(LCA)的路径的贡献减去即可.
那么加入贡献呢?按照我们刚才的式子统计即可.
这里也要维护一个链表,维护以当前点为终点的路径信息,每次走到一个点就把以它为终点的贡献都加上.同时把以它为起点的贡献也都加上.
还有一点,我们发现统计答案的时候,并不是直接加上桶中的元素即可.
因为这样很显然会算到不该对它产生贡献的点.
所以一个显然的思路是:
统计答案时相加的应该是进去这个点前的桶和回溯出来时的差.
这时显然桶里统计到的贡献都是合法的位于它的子树内的.
(Code:)

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
#define MEM(x,y) memset ( x , y , sizeof ( x ) )
#define rep(i,a,b) for (int i = (a) ; i <= (b) ; ++ i)
#define per(i,a,b) for (int i = (a) ; i >= (b) ; -- i)
#define pii pair < int , int >
#define one first
#define two second
#define rint read<int>
#define int long long
#define pb push_back
#define db double

using std::queue ;
using std::set ;
using std::pair ;
using std::max ;
using std::min ;
using std::priority_queue ;
using std::vector ;
using std::swap ;
using std::sort ;
using std::unique ;
using std::greater ;

template < class T >
    inline T read () {
        T 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 << 3 ) + ( x << 1 ) + ( ch - 48 ) ;
            ch = getchar () ;
       }
       return f * x ;
}

const int N = 300005 ;
int n , m , tot , head[N] , f[25][N] , t[N] ;
int deep[N] , w[N] , ans[N] , val[N] , s[N] ;
int cnt1[N<<1] , cnt2[N<<1] , dis[N] , ss[N] ;
vector < int > G[N] ;

inline void dfs (int cur , int anc , int dep) {
    f[0][cur] = anc ; deep[cur] = dep ;
    for (int i = 1 ; ( 1 << i ) <= dep ; ++ i)
        f[i][cur] = f[i-1][f[i-1][cur]] ;
    for (int k : G[cur] ) {
        if ( k == anc ) continue ;
        dfs ( k , cur , dep + 1 ) ;
    }
    return ;
}

inline int LCA (int x , int y) {
    if ( deep[x] < deep[y] ) swap ( x , y ) ;
    int k = log2 ( deep[x] ) ;
    for (int i = k ; i >= 0 ; -- i)
        if ( deep[f[i][x]] >= deep[y] ) 
            x = f[i][x] ;
    if ( x == y ) return x ;
    for (int i = k ; i >= 0 ; -- i)
        if ( f[i][x] != f[i][y] )
            x = f[i][x] , y = f[i][y] ;
    return f[0][x] ;
}

int head1[N] , head2[N] , tot1 , tot2 ;
struct mylist { int to , next ; } l1[N] , l2[N] ;

inline void insert1 (int x , int y) {
    l1[++tot1].next = head1[x] ;
    l1[tot1].to = y ; head1[x] = tot1 ;
    return ;
}

inline void insert2 (int x , int y) {
    l2[++tot2].next = head2[x] ;
    l2[tot2].to = y ; head2[x] = tot2 ;
    return ;
}

inline void solve (int cur) {
    int tmp = cnt1[w[cur]+deep[cur]] , _tmp = cnt2[w[cur]-deep[cur]+N] ;
    for (int k : G[cur] ) { if ( k == f[0][cur] ) continue ; solve ( k ) ; }
    cnt1[deep[cur]] += ss[cur] ;
    for (int i = head1[cur] ; i ; i = l1[i].next) {
        int k = l1[i].to ;
        ++ cnt2[dis[k]-deep[t[k]]+N] ;
    }
    ans[cur] += ( ( cnt1[w[cur]+deep[cur]] - tmp ) + ( cnt2[w[cur]-deep[cur]+N] - _tmp ) ) ;
    for (int i = head2[cur] ; i ; i = l2[i].next) {
        int k = l2[i].to ;
        -- cnt1[deep[s[k]]] ;
        -- cnt2[dis[k]-deep[t[k]]+N] ;
    }
    return ;
}

signed main (int argc , char * argv[]) {
    n = rint () ; m = rint () ;
    rep ( i , 2 , n ) {
        int u = rint () , v = rint () ;
        G[u].pb ( v ) ; G[v].pb ( u ) ;
    }
    dfs ( 1 , 0 , 1 ) ; f[0][1] = 1 ;
    rep ( i , 1 , n ) w[i] = rint () ;
    rep ( i , 1 , m ) {
        s[i] = rint () ; t[i] = rint () ;
        ++ ss[s[i]] ; int tmp = LCA ( s[i] , t[i] ) ;
        dis[i] = deep[s[i]] + deep[t[i]] - deep[tmp] * 2 ;
        insert1 ( t[i] , i ) ; insert2 ( tmp , i ) ;
        if ( deep[tmp] + w[tmp] == deep[s[i]] ) -- ans[tmp] ;
    }
    solve ( 1 ) ;
    rep ( i , 1 , n ) printf ("%lld " , ans[i] ) ;
    return 0 ;
}