CH#56C（LCA+dfs序）

题目传送门

性质是：把节点dfs序以后，异象石按这个序号排序，然后相邻两两求树上距离，这些距离的和除以二就是最小斯坦纳树。

插入删除的具体操作是根据我们上述性质，用一个set维护dfn，比如插入x，则ans加上：（set里的，即之前已经插进来的）左x + x右 - 左右。

 const int maxn = 1e5 + ;
 typedef set<ll> S;
 typedef S::iterator Sit;

 int n, m, t, tot, Time;
 int head[maxn], to[maxn << ], nxt[maxn << ];
 int dfn[maxn], mp[maxn];
 ll val[maxn << ], dis[maxn][];

 int f[maxn][], d[maxn];

 S s;
 ll ans;

 inline void add(int u, int v, ll cost) {
     to[++tot] = v, val[tot] = cost, nxt[tot] = head[u], head[u] = tot;
 }

 inline void bfs() {
     queue<int> Q;
     Q.push(), d[] = ;

     while (!Q.empty()) {
         int x = Q.front(); Q.pop();

         for (int i = head[x]; i; i = nxt[i]) {
             int y = to[i];
             if (d[y])    continue;

             d[y] = d[x] + ;
             dis[y][] = val[i];
             f[y][] = x;

             rep(j, , t) {
                 f[y][j] = f[f[y][j - ]][j - ];
                 dis[y][j] = dis[f[y][j - ]][j - ] + dis[y][j - ];
             }

             Q.push(y);
         }
     }
 }

 inline void dfs(int cur, int fa) {
     dfn[cur] = ++Time;
     mp[Time] = cur;

     for (int i = head[cur]; i; i = nxt[i]) {
         int v = to[i];
         if (v == fa)    continue;
         dfs(v, cur);
     }
 }

 inline Sit getL(Sit it) {
     if (it == s.begin())    return --s.end();
     return --it;
 }

 inline Sit getR(Sit it) {
     if (it == --s.end())    return s.begin();
     return ++it;
 }

 inline ll lca(int x, int y) {
     ll ret = ;

     if (d[x] > d[y])    swap(x, y);

     irep(i, t, )
         if (d[f[y][i]] >= d[x]) {
             ret += dis[y][i];
             y = f[y][i];
         }

     if (x == y)    return ret;

     irep(i, t, )
         if (f[x][i] != f[y][i]) {
             ret += dis[x][i] + dis[y][i];
             x = f[x][i], y = f[y][i];
         }

     return ret + dis[x][] + dis[y][];
 }

 int main() {
     read(n);
     rep(i, , n - ) {
         int u, v;
         ll cost;
         read(u), read(v), read(cost);
         add(u, v, cost), add(v, u, cost);
     }

     t = (int)(log(n) / log()) + ;
     bfs();
     dfs(, );

     read(m);
     rep(i, , m) {
         char str[];
         scanf("%s", str);

         if (str[] == '?') {
             writeln(ans / );
         } else {
             int x;
             read(x);

             if (str[] == '+') {
                 if (s.size()) {
                     Sit R = s.lower_bound(dfn[x]);
                     if (R == s.end())    R = s.begin();
                     Sit L = getL(R);

                     ans += lca(mp[*L], x) + lca(x, mp[*R]) - lca(mp[*L], mp[*R]);
                 }
                 s.insert(dfn[x]);
             } else {
                 Sit it = s.find(dfn[x]);
                 Sit L = getL(it), R = getR(it);

                 ans -= lca(mp[*L], x) + lca(x, mp[*R]) - lca(mp[*L], mp[*R]);
                 s.erase(it);
             }
         }
     }

     return ;
 }