树分基础 bzoj 1468

我们对于一棵树，我们找一个根，然后统计过这个点的路径有多少符合要求。怎么搞呢？我们可以先维护一个数据结构，然后把先把根作为一个距离自己为0的点放进去，然后对于每一棵子树，先找出所有的与之前的数据结构的东西进行统计，然后放入数据结构，递归每一棵子树，就可以搞了。为了保证复杂度，所以每一次选重心提起来。还是比较好些，然后我写的splay就莫名的慢，想快的可以写treap之类的(' '     ) 

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

typedef long long ll;
const ll maxn = 100010;
const ll INF = 0x3f3f3f3f;

struct node {
    ll data, weight, size; 
    node *son[2], *fa;
}e[maxn]; ll ne = 0;
node* root;

void update(node* x) {
    x-> size = x-> weight;
    for(ll i = 0; i < 2; ++ i) {
        if(x-> son[i]) x-> size += x-> son[i]-> size;
    }
}

void rotate(node *x, ll f) {
    node* t = x-> fa;
    if(t-> fa) {
        if(t-> fa-> son[0] == t) t-> fa-> son[0] = x;
        else t-> fa-> son[1] = t;
    }
    x-> fa = t-> fa, x-> size = t-> size, t-> fa = x;
    t-> son[f] = x-> son[!f];
    if(x-> son[!f]) x-> son[!f]-> fa = t;
    x-> son[!f] = t;
    update(t);
}

void splay(node* x, node* f) {
    while(x-> fa != f) {
        if(x-> fa-> fa == f) {
        ll a = x-> fa-> son[0] == x ? 0 : 1;
        rotate(x, a);
        }
        else {
            node* t = x-> fa, *r = t-> fa;
            ll a = r-> son[0] == t ? 0 : 1;
            ll b = t-> son[0] == x ? 0 : 1;
            if(a == b) rotate(t, a), rotate(x, b);
            else rotate(x, b), rotate(x, a);
        }
    }
    if(x-> fa == NULL) root = x;
}

node* newnode(ll v) {
    node* x = e + ne ++;
    x-> data = v, x-> size = x-> weight = 1;
    x-> son[0] = x-> son[1] = NULL;
    return x;
}

void insert(ll v) {
    node* x = root;
    while(x) {
        x-> size ++;
        if(x-> data == v) {
            x-> weight ++;
            splay(x, NULL); break;
        }
        else {
            ll a = x-> data > v ? 0 : 1;
            if(x-> son[a]) x = x-> son[a];
            else {
                x-> son[a] = newnode(v);
                x-> son[a]-> fa = x;
                splay(x-> son[a], NULL);
                break;
            }
        }
    }
    if(!x) root = newnode(v), root-> fa = NULL;
}

ll work(ll v) {
    node *x = root; ll ret = 0;
    while(x) {
        if(x-> data <= v) {
            ret += x-> weight + (x-> son[0] ? x-> son[0]-> size : 0);
            x = x-> son[1];
        }
        else x = x-> son[0];
    }
    return ret;
}

struct edge {
    ll t, d;
    edge* next;
}se[maxn * 2], *head[maxn]; ll oe = 0;
ll n, m, a[maxn], top = 0;
ll s[maxn], stop = 0;

void addedge(ll f, ll t, ll d) {
    se[oe].t = t, se[oe].d = d, se[oe].next = head[f], head[f] = se + oe ++;
}

bool vis[maxn]; ll size[maxn], dis[maxn];

void dfs(ll x, ll fa) {
    size[x] = 1; s[++ stop] = x;
    for(edge* p = head[x]; p; p = p-> next) if(p-> t != fa && !vis[p-> t]) dfs(p-> t, x), size[x] += size[p-> t];
}

void find_dis(ll x, ll fa) {
    a[++ top] = x;
    for(edge* p = head[x]; p; p = p-> next) {
        if(!vis[p-> t] && p-> t != fa) dis[p-> t] = dis[x] + p-> d, find_dis(p-> t, x);
    }
}

ll int_get() {
    ll x = 0; char c = (char)getchar(); bool f = 0;
    while(!isdigit(c) && c != '-') c = (char)getchar();
    if(c == '-') c = (char)getchar(), f = 1;
    while(isdigit(c)) {
        x = x * 10 + (int)(c - '0');
        c = (char)getchar();
    }
    if(f) x = -x;
    return x;
}

void read() {
    n = int_get();
    for(ll i = 1; i <= n - 1; ++ i) {
        ll u, v, w; u = int_get(), v = int_get(), w = int_get();
        addedge(u, v, w), addedge(v, u, w);
    }
    m = int_get();
}

ll ans = 0;

void sov(ll x) {
    stop = 0;
    dfs(x, 0); ll tot = size[x];
    if(tot == 1) return; 
    ll Max = INF, pos = x; 
    for(ll j = 1; j <= stop; ++ j) {
        ll i = s[j];
        ll tmax = 0;
        for(edge* p = head[i]; p; p = p-> next) if(!vis[p-> t] && size[x] > size[p-> t]) tmax = max(tmax, size[p-> t]);
        tmax = max(tot - size[i], tmax);
        if(Max > tmax) Max = tmax, pos = i;
    }
    ll rt = pos; root = NULL; ne = 0;
    insert(0);
    for(edge* p = head[rt]; p; p = p-> next) {
        if(!vis[p-> t]) {
            top = 0, dis[p-> t] = p-> d, find_dis(p-> t, rt);
            for(ll i = 1; i <= top; ++ i) ans += work(m - dis[a[i]]);
            for(ll i = 1; i <= top; ++ i) insert(dis[a[i]]);
        }
    }
    vis[rt] = 1;
    for(edge* p = head[rt]; p; p = p-> next) {
        if(!vis[p-> t]) sov(p-> t);
    }
}

int main() {
    freopen("test.in", "r", stdin);
    freopen("test.out", "w", stdout);
    read(); 
    memset(vis, 0, sizeof(vis));
    sov(1);
    printf("%lld
", ans);
    return 0;
}