标签：

Annoying problem

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

Case #1:
0
6
8
8
4

题目大意：给出一棵树，每个边都有一个权值，现在有一个空的集合，两种操作，1 x吧x节点放到集合中(如果还没放入)，2 x把x节点从集合中拿出来(已放入)。现在要求将集合中的点之间的边权之和

dfn[u] - dfn[ lca(x,u) ] - dfn[ lca(y,u) ] + dfn[ lca(x,y) ]

神一样的公式呀，表示比赛时根本就没想过要推公式，，，，，

先说这个公式怎么用，首先dfs一个顺序，加一个节点u，如果u节点的dfs序，在集合中节点的dfs序之间，那么找到最接近的(u的dfs序)的两个数为x和y；如果u节点的dfs序在集合中节点的dfs序的一侧，那么x和y为集合中dfs序的最大值和最小值，，，，，这样带入公式中求的就是添加这个节点所带来的需要添加的距离，删除一个节点和添加时一样的。

假设节点要连接到一个链中，链的定点(x,y)，那么u连接到x的距离是dfn[u] + dfn[x] - 2dfn[ lca(u,x) ] ;

u连接到y的距离dfn[u] + dfn[y] - 2dfn[ lca(u,x) ] :

x连接到y的距离dfn[x] + dfn[y] - 2dfn[ lca(x,y) ] :

u连接到x-y这个链的距离 = (u到y+u到x-x到y)/2

#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
using namespace std ;
#define maxn 100050
struct E{
    int v , w ;
    int next ;
}edge[maxn<<1];
int head[maxn] , cnt ;
int rmq[maxn][20] ;
int dep[maxn] , p[maxn] , belong[maxn] , cid ;
int vis[maxn] , dfn[maxn] ;
set<int> s ;
set<int>::iterator iter ;
void add(int u,int v,int w) {
    edge[cnt].v = v ; edge[cnt].w = w ;
    edge[cnt].next = head[u] ; head[u] = cnt++ ;
    edge[cnt].v = u ; edge[cnt].w = w ;
    edge[cnt].next = head[v] ; head[v] = cnt++ ;
}
void dfs(int fa,int u) {
    int i , j , v ;
    p[u] = ++cid ;
    belong[cid] = u ;
    for(i = head[u] ; i != -1 ; i = edge[i].next ) {
        v = edge[i].v ;
        if( v == fa ) continue ;
        dfn[v] = dfn[u] + edge[i].w ;
        rmq[v][0] = u ;
        for(j = 1 ; j < 19 ; j++)
            rmq[v][j] = rmq[ rmq[v][j-1] ][j-1] ;
        dep[v] = dep[u] + 1 ;
        dfs(u,v) ;
    }
}
int lca(int u,int v) {
    if( dep[u] < dep[v] ) swap(u,v) ;
    int i ;
    for(i = 19 ; i >= 0 ; i--) {
        if( dep[ rmq[u][i] ] >= dep[v] )
            u = rmq[u][i] ;
        if( u == v ) return u ;
    }
    for(i = 19 ; i >= 0 ; i--) {
        if( rmq[u][i] != rmq[v][i] ) {
            u = rmq[u][i] ;
            v = rmq[v][i] ;
        }
    }
    return rmq[u][0] ;
}
int solve(int u) {
    if( s.empty() ) return 0 ;
    int x , y ;
    iter = s.upper_bound(u) ;
    if( iter == s.end() || iter == s.begin() ) {
        x = belong[ *s.begin() ] ;
        y = belong[ *s.rbegin() ] ;
    }
    else {
        x = belong[*iter] ;
        iter-- ;
        y = belong[*iter] ;
    }
    u = belong[u] ;
    return dfn[u] - dfn[ lca(x,u) ] - dfn[ lca(y,u) ] + dfn[ lca(x,y) ] ;
}
int main() {
    int Step = 0 , t ;
    int n , m ;
    int i , j , u , v , w , k ;
    int ans ;
    scanf("%d", &t) ;
    while( t-- ) {
        memset(head,-1,sizeof(head)) ;
        memset(rmq,0,sizeof(rmq)) ;
        memset(dfn,0,sizeof(dfn)) ;
        memset(vis,0,sizeof(vis)) ;
        cnt = cid = ans = 0 ;
        s.clear() ;
        scanf("%d %d", &n, &m) ;
        for(i = 1 ; i < n ; i++) {
            scanf("%d %d %d", &u, &v, &w) ;
            add(u,v,w) ;
        }
        dep[1] = 1 ;
        dfs(-1,1) ;
        printf("Case #%d:\n", ++Step) ;
        while( m-- ) {
            scanf("%d %d", &k, &u) ;
            u = p[u] ;
            if( k == 1 ) {
                if( !vis[u] ) {
                    vis[u] = 1 ;
                    ans += solve(u) ;
                    s.insert(u) ;
                }
            }
            else {
                if( vis[u] ) {
                    vis[u] = 0 ;
                    s.erase(u) ;
                    ans -= solve(u) ;
                }
            }
            printf("%d\n", ans) ;
        }
    }
    return 0 ;
}

hdu5296(2015多校1)--Annoying problem(lca+一个公式)

标签：

原文地址：http://blog.csdn.net/winddreams/article/details/47008529