bzoj 1095

传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=1095

首先我必须得感谢yzjc的细心讲解和某岛的题解，如果没有的话我相信我现在还在纠结。。不过某岛的上面写的后面我没有看懂，然后yzjc就给我讲了一个可看的合并。不过由于我自己写的比较的丑，在bzoj的跑的还是比较的慢。。。

首先这道题需要转成一个括号序列，然后我们可以发现两个点之间的路径可以通过某种加法得到，假设向下走为+1, 向上走是 -1，并且我们在这个序列中加入原来的点，也就是一个点在序列中会有三个点表示，这个时候发现两点之间的距离是可以分为两段——一段向上的－1的然后一段＋1的（一段中出现的可匹配的括号已经合并了），答案就是前段的－1的和的相反数，加上后面的＋1的和。 而如果要使值最大，在不考虑点颜色的情况下，那么这个分割点的应该是lca，不过这个不重要，因为需要找到的是一个值最大，lca具体事哪个位置并不重要

那么考虑答案合并的时候，对于一个答案，那么他可以被lson的答案和rson的答案更新，同时还有可能有中间的一段。而中间一段的分割点可能在中间点的左边或者右边。在左边的时候那么就是左边的后缀的最大的答案加上右边最大的前缀和（相当于右边一定是向下的一段） 在右边的时候就是左边后缀最小和的绝对值＋右边前缀答案最大值。然后前缀后缀和参照最大字段和，然后最大答案前缀和后缀类似，前缀的话是左边的前缀，左边的全局答案（新的量）＋右边的前缀最大和，左边的和的相反数家右边的前缀最大答案。而刚刚提到的全局答案指的是从区间左边到区间右边整个的答案类似全局的和。 而这个更新方式相当于是找个最大值（因为找lca相当于找一个最大值）， 参考一下前面的答案合并就好了

不知道说了这么多好像有点乱＝ ＝ 不过确实他就是这么的乱。 然后考虑颜色，黑点0，白点INF表示不可取，边的前缀答案和后缀答案及其相关量也是INF，因为边不能单独存在而是要必须要黑点最为端点

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

 const int maxn = ;
 const int INF = 0x3f3f3f3f;

 struct node {
     int data, ans, sum, lsum, rsum, lans, rans;
     node *l ,*r;
 }tr[maxn * ]; int trne = ;
 node* root; 

 void test(node* x, int l, int r) {
     cout << l <<" "<< r <<" "<< x-> data <<" " << x-> ans <<" "<< x-> sum <<" "<< x-> lsum <<" "<< x-> rsum <<" "<<x-> lans <<" "<< x-> rans <<" "<< endl;
     if(l ^ r) {
         int mid = (l + r) >> ;
         test(x-> l, l, mid), test(x-> r, mid + , r);
     }
 }

 node* build(int l, int r) {
     node* now = tr + trne ++;
     if(l ^ r) {
         int mid = (l + r) >> ;
         now-> l = build(l, mid);
         now-> r = build(mid + , r);
     }
     return now;
 }

 void update(node *x) {
     if(x-> l) {
         x-> data = max(max(x-> l-> data, x-> r-> data), max(x-> l-> rans + x-> r-> lsum, -x-> l-> rsum + x-> r-> lans));
         x-> ans = max(x-> l-> ans + x-> r-> sum, -x-> l-> sum + x-> r-> ans);
         x-> sum = x-> l-> sum + x-> r-> sum;
         x-> lsum = max(x-> l-> lsum, x-> l-> sum + x-> r-> lsum);
         x-> rsum = min(x-> r-> rsum, x-> r-> sum + x-> l-> rsum);
         x-> lans = max((x-> l-> lans), max(x-> l-> ans + x-> r-> lsum, -x-> l-> sum + x-> r-> lans));
         x-> rans = max((x-> r-> rans), max(x-> l-> rans + x-> r-> sum, -x-> l-> rsum + x-> r-> ans));
     }
 }  

 void insert(node* x, int l, int r, int v, int pos, int col) {
     if(l == r) {
         x-> ans = x-> data = x-> sum = x-> lsum = x-> rsum = x-> lans = x-> rans = ;
         x-> data = -INF;
         if(!v) {
             if(col == ) x-> lsum = -INF, x-> rsum = INF, x-> lans = -INF, x-> rans = -INF, x-> ans = -INF, x-> data = -INF;
         }
         else {
             x-> sum = v; x-> ans = abs(v); x-> data = abs(v);
             if(v > ) x-> lsum = -INF, x-> rsum = INF,  x-> lans = x-> rans = -INF, x-> data = -INF, x-> ans = ;
             else x-> rsum = INF, x-> lsum = -INF, x-> lans = x-> rans = -INF, x-> data = -INF, x-> ans = ;
         }
     }
     else {
         int mid = (l + r) >> ;
         if(pos <= mid) insert(x-> l, l, mid, v, pos, col);
         else insert(x-> r, mid + , r, v, pos, col);
         update(x);
     }
 }

 struct edge {
     int t; edge* next;
 }e[maxn * ], *head[maxn]; int ne = ;

 void addedge(int f, int t) {
     e[ne].t = t, e[ne].next = head[f], head[f] = e + ne ++;
 }

 int in[maxn], map[maxn], out[maxn], c[maxn], num = , n, m;
 int cnt = ;

 void dfs(int x, int fa) {
     in[x] = num ++, map[x] = num ++;
     for(edge* p = head[x]; p; p = p-> next) {
         if(p-> t != fa) dfs(p-> t, x);
     }
     out[x] = num ++;
 }

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

 void read() {
     n = int_get(); cnt = n;
     for(int i = ; i < n; ++ i) {
         int u, v; u = int_get(), v = int_get();
         addedge(u, v), addedge(v, u);
     }
     for(int i = ; i <= n; ++ i) c[i] = ;
     dfs(, ); num -= ; root = build(, num);
     for(int i = ; i <= n; ++ i) {
         insert(root, , num, , map[i], c[i]);
         if(i != ) {
             insert(root, , num, , in[i], );
             insert(root, , num, -, out[i], );
         }
     }
 }

 void sov() {
     m = int_get();
     while(m --) {
         char s[]; scanf("%s", s + );
         if(s[] == 'G') {
             if(cnt <= ) printf("%d\n", cnt - );
             else printf("%d\n", root-> data);
         }
         if(s[] == 'C') {
             int x = int_get();
             if(c[x]) cnt --;
             else cnt ++;
             c[x] = !c[x];
             insert(root, , num, , in[x], );
             insert(root, , num, , map[x], c[x]);
             insert(root, , num, -, out[x], );
         }
     }
     //test(root, 1, num); cout << endl;
 }

 int main() {
     freopen("test.in", "r", stdin);
     freopen("test.out", "w", stdout);
     read(); sov();
     //update(root-> r);
     return ;
 }