CH#56C（LCA+dfs序）

题目传送门

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

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

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

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

int f[maxn][20], 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(1), d[1] = 1;

    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] + 1;
            dis[y][0] = val[i];
            f[y][0] = x;

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

            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 = 0;

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

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

    if (x == y)    return ret;

    irep(i, t, 0)
        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][0] + dis[y][0];
}

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

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

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

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

            if (str[0] == '+') {
                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 0;
}