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 = ;
 struct arc {
     int to,w,next;
     arc(int x = ,int y = ,int z = -) {
         to = x;
         w = y;
         next = z;
     }
 } e[maxn*];
 int head[maxn],fa[maxn][],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][] = u;
         dep[e[i].to] = dep[u] + ;
         for(int j = ; j < ; ++j)
             fa[e[i].to][j] = fa[fa[e[i].to][j-]][j-];
         dfs(e[i].to,u);
     }
 }
 int LCA(int u,int v) {
     if(dep[u] < dep[v]) swap(u,v);
     int log;
     for(log = ; (<<log) <= dep[u]; ++log);
     for(int i = log-; i >= ; --i)
         if(dep[u] - (<<i) >= dep[v]) u = fa[u][i];
     if(u == v) return u;
     for(int i = log-; i >= ; --i) {
         if(fa[u][i] != fa[v][i]) {
             u = fa[u][i];
             v = fa[v][i];
         }
     }
     return fa[u][];
 }
 set<int>st;
 int solve(int u) {
     if(st.empty()) return ;
     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 = ;
     scanf("%d",&kase);
     while(kase--) {
         memset(head,-,sizeof head);
         memset(used,false,sizeof used);
         scanf("%d%d",&n,&q);
         for(int i = ti = tot = ; i < n-; ++i) {
             scanf("%d%d%d",&u,&v,&w);
             add(u,v,w);
             add(v,u,w);
         }
         dep[] = ;
         int ret = dfn[] = ;
         dfs(,-);
         st.clear();
         printf("Case #%d:\n",cs++);
         while(q--) {
             scanf("%d%d",&op,&u);
             u = timeStamp[u];
             if(op ==  && !used[u]) {
                 used[u] = true;
                 ret += solve(u);
                 st.insert(u);
             } else if(op ==  && used[u]) {
                 used[u] = false;
                 st.erase(u);
                 ret -= solve(u);
             }
             printf("%d\n",ret);
         }
     }
     return ;
 }