HDU 5296 Annoying problem (LCA，变形)

题意：

　　给一棵n个节点的树，再给q个操作，初始集合S为空，每个操作要在一个集合S中删除或增加某些点，输出每次操作后：要使得集合中任意两点互可达所耗最小需要多少权值。（记住只能利用原来给的树边。给的树边已经有向。10万个点，10万个操作）

思路：只能用 O(nlogn)的复杂度。官方题解：

　　

　　重点也就是要找到集合S中的以x和y为端点一条链，使得操作点u到达这条链是最近的。删除也是这样，找到这条链，删除u到这链的路长。

步骤：

　　（1）记录从根遍历的DFS序。

　　（2）计算每个点到根的路径所经过边的权之和。

　　（3）对于每个操作，无论哪种，如果u的序最大，那么在比u的序小的里面挑一个最大x和一个最小y。再按照式子就可算出，如果是插入就加上这个权和，否则就是减去。

 #include <bits/stdc++.h>
 #define LL long long
 #define pii pair<int,int>
 #define INF 0x7f7f7f7f
 using namespace std;
 const int N=;
 vector<int> chld[N];    //孩子
 unordered_map<int,int> weight[N];
 int dis[N];
 int mapp[N];
 int seq[N];          //seq记录DFS序
 int anti_seq[N];    //anti记录第几个访问的是谁
 bool inset[N];
 int ans, num;
 set<int> sett;

 void DFS(int x)
 {
     seq[x]=++num;
     for(int i=; i<chld[x].size(); i++)
     {
         int t=chld[x][i];
         if(!seq[t])    DFS(t);
     }
 }

 unordered_map<int,int> vis;
 int LCA(int a,int b)
 {
     vis.clear();
     while(mapp[a])
     {
         vis[a]=;
         a=mapp[a];
     }
     vis[a]=;
     while( !vis[b] )    b=mapp[b];
     return b;
 }

 void cal_weight(int n)
 {
     for(int i=; i<=n; i++)
     {
         int sum=, s=i;
         while(mapp[s])
         {
             sum+=weight[mapp[s]][s];
             s=mapp[s];
         }
         dis[i]=sum;
     }
 }

 int ins(int u)
 {
     sett.insert(seq[u]);
     if(sett.size()==)  {ans=;return ;}

     set<int>::iterator it=sett.find(seq[u]);

     int x=, y=;
     if(*it==*sett.begin())    //已经是最小
     {
         x=anti_seq[*(++it)];
         y=anti_seq[*(sett.rbegin())];
     }
     else if(*it==*sett.rbegin()) //已经是最大
     {
         x=anti_seq[*(--it)];
         y=anti_seq[*(sett.begin())];
     }
     else
     {
         x=anti_seq[ *(--it)];
         y=anti_seq[ *(++(++it))  ];
     }

     ans+=dis[u]-dis[LCA(u,x )]- dis[LCA(u,y )] + dis[LCA(x,y)];
     return ans;
 }

 int del(int u)
 {
     if(sett.size()==)
     {
         sett.erase(seq[u]);
         ans=;
         return ;
     }

     set<int>::iterator it=sett.find(seq[u]);
     int x=, y=;
     if(*it==*sett.begin())    //已经是最小
     {
         x=anti_seq[*(++it)];
         y=anti_seq[*(sett.rbegin())];
     }
     else if(*it==*sett.rbegin()) //已经是最大
     {
         x=anti_seq[*(--it)];
         y=anti_seq[*(sett.begin())];
     }
     else
     {
         x=anti_seq[ *(--it)];
         y=anti_seq[ *(++(++it))  ];
     }
     ans-=dis[u]-dis[LCA(u,x )]- dis[LCA(u,y )] + dis[LCA(x,y)];
     sett.erase(seq[u]);
     return ans;
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int a, b, c, t, q, n, j=;
     cin>>t;
     while(t--)
     {
         scanf("%d%d", &n, &q);
         for(int i=; i<=n+; i++)    chld[i].clear(),weight[i].clear();

         memset(inset, , sizeof(inset));
         memset(seq, , sizeof(seq));
         memset(anti_seq, , sizeof(anti_seq));
         memset(mapp, , sizeof(mapp));
         memset(dis,,sizeof(dis));
         sett.clear();
         ans=;
         num=;

         for(int i=; i<n; i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             chld[a].push_back(b);
             weight[a][b]=c;
             mapp[b]=a;
         }
         printf("Case #%d:\n",++j);
         int root=n;        //获得树根
         while(mapp[root])   root=mapp[root];
         DFS(root);          //获得DFS序

         for(int i=; i<=n; i++)      anti_seq[seq[i]]=i;      //反向索引
         cal_weight(n);        //计算每个点到根的权
         while(q--)
         {
             scanf("%d%d",&a,&b);
             if(a==)    //如果不存在于集合中，则插，有则不插
             {
                 if(inset[b])    printf("%d\n", ans);  //已经存在，不必计算
                 else
                 {
                     inset[b]=;
                     printf("%d\n", ins(b));
                 }
             }
             else    //如果存在于集合中，则删，否则不删。
             {
                 if(inset[b])    //存在，要删
                 {
                     inset[b]=;
                     printf("%d\n",del(b));
                 }
                 else    printf("%d\n",ans);
             }
         }
     }
     return ;
 }

AC代码