HDU 5405 Sometimes Naive 树链剖分+bit*****

Sometimes Naive

Problem Description

 

Rhason Cheung had a naive problem, and asked Teacher Mai for help. But Teacher Mai thought this problem was too simple, sometimes naive. So she ask you for help.

She has a tree with n vertices, numbered from 1 to n. The weight of i-th node is wi.

You need to support two kinds of operations: modification and query.

For a modification operation u,w, you need to change the weight of u-th node into w.

For a query operation u,v, you should output ∑ni=1∑nj=1f(i,j). If there is a vertex on the path from u to v and the path from i to j in the tree, f(i,j)=wiwj, otherwise f(i,j)=0. The number can be large, so print the number modulo 109+7

 

Input

There are multiple test cases.

For each test case, the first line contains two numbers n,m(1≤n,m≤105).

There are n numbers in the next line, the i-th means wi(0≤wi≤109).

Next n−1 lines contain two numbers each, ui and vi, that means that there is an edge between ui and vi.

The following are m lines. Each line indicates an operation, and the format is "1 u w"(modification) or "2 u v"(query)(0≤w≤109)

 

Output

For each test case, print the answer for each query operation.

 

Sample Input

6 5
1 2 3 4 5 6
1 2
1 3
2 4
2 5
4 6
2 3 5
1 5 6
2 2 3
1 1 7
2 2 4

 

Sample Output

341
348
612

 

题意：

　   给你一棵n个节点的树，有点权。

　　要求支持两种操作：

　　　　操作1：更改某个节点的权值。

　　　　操作2：给定u，v， 求 Σw[i][j]   i , j 为任意两点且i到j的路径与u到v的路径相交。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
#define ls i<<1
#define rs ls | 1
#define mid ((ll+rr)>>1)
#define pii pair<int,int>
#define MP make_pair
typedef long long LL;
const long long INF = 1e18+1LL;
const double Pi = acos(-1.0);
const int N = 1e6+, M = 1e3+, mod = 1e9+, inf = 2e9;

LL aa[N],bb[N],in[N],out[N];
int dep[N],head[N],t=,sz[N],fa[N],indexS,top[N],pos[N],son[N];
struct ss{int to,next;}e[N*];
int n;
void add(int u,int v)
{e[t].to = v;e[t].next = head[u];head[u] = t++;}

void dfs(int u) {
    int k = ;
    sz[u] = ;
    if(u!=)dep[u] = dep[fa[u]] + ;
    for(int i = head[u]; i; i = e[i].next) {
        int to = e[i].to;
        if(to == fa[u]) continue;
        fa[to] = u;
        dfs(to);
        sz[u] += sz[to];
        if(sz[to] > sz[k]) k = to;
    }
    if(k) son[u] = k;
}
void dfs(int u,int chain) {
    int k = ;
    pos[u] = ++indexS;
    in[u] = indexS;
    top[u] = chain;
    if(son[u] > )
        dfs(son[u],chain);
    for(int i = head[u]; i; i = e[i].next) {
        int to = e[i].to;
        if(dep[to] > dep[u] && son[u] != to)
            dfs(to,to);
    }
    out[u] = indexS;
}

void update(int x,LL val,LL *sum) {
    for(int i = x; i < N; i += i&(-i)) {
        sum[i] += val;
        sum[i] %= mod;
    }
}
LL ask(int x,LL *sum) {
    LL res = ;
    for(int i = x; i; i-=i&(-i)) res += sum[i],res %= mod;
    return res;
}

LL allsum,C_tree[N],C_sqtree[N],a[N];
void update(int x,LL val) {
    int u = top[x];
    while(fa[u] > ) {
        LL all = ask(out[u],C_tree) - ask(in[u]-,C_tree);
        LL newall = (val - a[x])*(val - a[x])%mod + 1LL**all*(val-a[x])%mod;
        update(in[fa[u]],newall%mod,C_sqtree);
        u = top[fa[u]];
    }
    update(in[x],val-a[x],C_tree);
    a[x] = val;
}
LL query(int x,int y) {
    LL res = ,hav = ;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y);
        res += ask(in[x],C_sqtree) - ask(in[top[x]]-,C_sqtree);
        res %= mod;
        if(son[x]>) {
            LL all = ask(out[son[x]],C_tree) - ask(in[son[x]]-,C_tree);
            res += all*all;
            res %= mod;
        }
        if(hav>) {
            LL all = ask(out[hav],C_tree) - ask(in[hav]-,C_tree);
            res -= all * all;
            res %= mod;
        }
        hav = top[x];
        x = fa[hav];
    }
    if(dep[x] < dep[y]) swap(x,y);
    res += ask(in[x],C_sqtree) - ask(in[y]-,C_sqtree);
    res %= mod;
    if(fa[y] > ) {
        LL all = ((ask(out[],C_tree) - ask(out[y],C_tree) + ask(in[y]-,C_tree))%mod+mod)%mod;
        res += (all*all)%mod;
        res %= mod;
    }
    if(son[x]>) {
        LL all = ask(out[son[x]],C_tree) - ask(in[son[x]]-,C_tree);
        res += all*all;
        res %= mod;
    }
    if(hav>) {
        LL all = ask(out[hav],C_tree) - ask(in[hav]-,C_tree);
        res -= all * all;
        res %= mod;
    }
    return res;
}
int Q;
void init() {
    memset(head,,sizeof(head));
    t = ;
    indexS = ;
    allsum = ;
    memset(son,-,sizeof(son));
    son[] = ;
    memset(C_tree,,sizeof(C_tree));
    memset(C_sqtree,,sizeof(C_sqtree));
}
int main() {
    while(scanf("%d%d",&n,&Q)!=EOF) {
        init();
        for(int i = ; i <= n; ++i)
            scanf("%I64d",&a[i]);
        allsum = allsum*allsum%mod;
        for(int i = ; i < n; ++i) {
            int x,y;
            scanf("%d%d",&x,&y);
            add(x,y),add(y,x);
        }
        fa[] = -;
        dfs();
        dfs(,);
        for(int i = ; i <= n; ++i) {
            LL uu = a[i];
            a[i] = ;
            update(i,uu);
        }
        while(Q--) {
            int op,x;
            LL y;
            LL all = ask(out[],C_tree);
            scanf("%d%d%I64d",&op,&x,&y);
            if(op == ) {
                update(x,y);
            }
            else
                printf("%I64d\n",((all*all%mod - query(x,y)) % mod + mod)%mod);
        }
    }
    return ;
}