2015 Multi-University Training Contest 1 hdu 5296 Annoying problem

Annoying problem

Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1006    Accepted Submission(s): 330

Problem Description

Coco has a tree, whose nodes are conveniently labeled by 1,2,…,n, which has n-1 edge，each edge has a weight. An existing set S is initially empty.
Now there are two kinds of operation:

1 x： If the node x is not in the set S, add node x to the set S
2 x： If the node x is in the set S,delete node x from the set S

Now there is a annoying problem: In order to select a set of edges from tree after each operation which makes any two nodes in set S connected. What is the minimum of the sum of the selected edges’ weight ?

 

Input

one integer number T is described in the first line represents the group number of testcases.( T<=10 ) 
For each test:
The first line has 2 integer number n,q(0<n,q<=100000) describe the number of nodes and the number of operations.
The following n-1 lines each line has 3 integer number u,v,w describe that between node u and node v has an edge weight w.(1<=u,v<=n,1<=w<=100)
The following q lines each line has 2 integer number x,y describe one operation.（x=1 or 2,1<=y<=n）

 

Output

Each testcase outputs a line of "Case #x:" , x starts from 1.
The next q line represents the answer to each operation.

 

Sample Input

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

 

Sample Output

Case #1:

0

6

8

8

4

 

Author

FZUACM

 

Source

2015 Multi-University Training Contest 1

 

解题：LCA居然可以解决这种问题。。。

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct arc {
    int to,w,next;
    arc(int x = 0,int y = 0,int z = -1) {
        to = x;
        w = y;
        next = z;
    }
} e[maxn*20];
int head[maxn],fa[maxn][20],dep[maxn],ti,tot;
int n,q,timeStamp[maxn],node[maxn],dfn[maxn];
void add(int u,int v,int w) {
    e[tot] = arc(v,w,head[u]);
    head[u] = tot++;
}
void dfs(int u,int f) {
    timeStamp[u] = ++ti;
    node[ti] = u;
    for(int i = head[u]; ~i; i = e[i].next) {
        if(e[i].to == f) continue;
        dfn[e[i].to] = dfn[u] + e[i].w;
        fa[e[i].to][0] = u;
        dep[e[i].to] = dep[u] + 1;
        for(int j = 1; j < 19; ++j)
            fa[e[i].to][j] = fa[fa[e[i].to][j-1]][j-1];
        dfs(e[i].to,u);
    }
}
int LCA(int u,int v) {
    if(dep[u] < dep[v]) swap(u,v);
    int log;
    for(log = 1; (1<<log) <= dep[u]; ++log);
    for(int i = log-1; i >= 0; --i)
        if(dep[u] - (1<<i) >= dep[v]) u = fa[u][i];
    if(u == v) return u;
    for(int i = log-1; i >= 0; --i) {
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}
set<int>st;
int solve(int u) {
    if(st.empty()) return 0;
    int x,y;
    auto it = st.upper_bound(u);
    if(it == st.begin() || it == st.end()) {
        x = node[*st.begin()];
        y = node[*st.rbegin()];
    } else {
        x = node[*it];
        y = node[*(--it)];
    }
    u = node[u];
    return dfn[u] - dfn[LCA(x,u)] - dfn[LCA(y,u)] + dfn[LCA(x,y)];
}
bool used[maxn];
int main() {
    int kase,u,v,w,op,cs = 1;
    scanf("%d",&kase);
    while(kase--) {
        memset(head,-1,sizeof head);
        memset(used,false,sizeof used);
        scanf("%d%d",&n,&q);
        for(int i = ti = tot = 0; i < n-1; ++i) {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        dep[1] = 1;
        int ret = dfn[1] = 0;
        dfs(1,-1);
        st.clear();
        printf("Case #%d:
",cs++);
        while(q--) {
            scanf("%d%d",&op,&u);
            u = timeStamp[u];
            if(op == 1 && !used[u]) {
                used[u] = true;
                ret += solve(u);
                st.insert(u);
            } else if(op == 2 && used[u]) {
                used[u] = false;
                st.erase(u);
                ret -= solve(u);
            }
            printf("%d
",ret);
        }
    }
    return 0;
}