NOIP模拟赛异象石

Posted 2020-10-13

Description

Adera是Microsoft应用商店中的一款解谜游戏。

异象石是进入Adera中异时空的引导物，在Adera的异时空中有一张地图。这张地图上有N个点，有N-1条双向边把它们连通起来。起初地图上没有任何异象石，在接下来的M个时刻中，每个时刻会发生以下三种类型的事件之一：

1.地图的某个点上出现了异象石（已经出现的不会再次出现）；

2.地图某个点上的异象石被摧毁（不会摧毁没有异象石的点）；

3.向玩家询问使所有异象石所在的点连通的边集的总长度最小是多少。

请你作为玩家回答这些问题。

Input Format

第一行有一个整数N，表示点的个数。

接下来N-1行每行三个整数x,y,z，表示点x和y之间有一条长度为z的双向边。

第N+1行有一个正整数M。

接下来M行每行是一个事件，事件是以下三种格式之一：

• x 表示点x上出现了异象石

• x表示点x上的异象石被摧毁

?表示询问使当前所有异象石所在的点连通所需的边集的总长度最小是多少。

Output Format

对于每个 ?事件，输出一个整数表示答案。

Sample Input

6
1 2 1
1 3 5
4 1 7
4 5 3
6 4 2
10
+ 3
+ 1
?
+ 6
?
+ 5
?
- 6
- 3
?

Sample Output

5
14
17
10

Hint

数据范围与约定

对于30%的数据，1?≤?n, m?≤?1000。

对于另20%的数据，地图是一条链，或者一朵菊花。

对于100%的数据，1?≤?n, m?≤?10^5, 1?≤?x, y?≤?n, x?≠?y, 1?≤?z?≤?10^9。

solution

雾。一道很巧妙的思维题。废话不多说，上题解。

 

题目大意就是，给一棵树，要求动态维护一个值：使所选出的点连通的边的最小权值和（最小的意思就是不需要更多的边，已经达到连通状态，因为是树，所以这个边集是唯一的）。有加入和删除所选定的点的操作。

 

如图，对于当前这棵树：

我们选择的节点为图中标号1、2、3的三个节点，那么√标注的边的权值和就是我们所求的。设lca(a, b)为a,b到两个点最近公共祖先的路径长度之和。那么，这些边的权值和就是(lca(1,2)+lca(2,3)+lca(3,1))/2。并发现这个和是这样子的： 

这一圈，就是寻宝游戏的答案，就是异象石的答案乘以2的结果。可以想到，对于这样的点集，要求的这个“圈”，可以通过两两点之间的lca加和得到。对于一个点的序列a[1]~a[i]，就是lca(a[1],a[2])+lca(a[2],a[3])+……+lca(a[i-1],a[i])+lca(a[i],1)。而这个序列点的顺序是什么？DFS序。画一画图很容易就明白了。

 

所以，我们先预处理出这棵树节点的DFS序的序号（就是在DFS过程中，这个点是第几个被访问到的）。在维护的过程中，假设加入一个点后，它的位置是i，那么对于答案ans，我们需要做的改变就是ans += lca(a[i-1],a[i])+lca(a[i],a[i+1])-lca(a[i-1],a[i+1]);这个也很容易明白吧。相反，如果删除一个点，它原本的位置是i，只需要ans -= lca(a[i-1],a[i])+lca(a[i],a[i+1])-lca(a[i-1],a[i+1]);【切记不要每次修改只搞一个bool数组记录而每次询问都全部重新计算，而是要动态维护ans】

 

那么用什么来做到维护a序列呢？STL里的set就可以。s.insert(x);插入x， s.erase(x);删除x， s.lower_bound(x);返回一个迭代器，指向集合中第一个大于或等于x的元素。集合键值就是DFS序的编号，用这些函数就可以维护a序列，并且求出a[i],a[i-1],a[i+1]是哪些节点。

然而本蒟蒻似乎一时脑抽打了splay。。。。。。

#include<cstdio>
#define LL long long
inline void Swap(int &a,int &b){a^=b;b^=a;a^=b;}
LL Ans,Dis[100024];
int N,M,Index,dfn[100024],Rank[100024];
int F[100024][18],Dep[100024];
int Root,cnt,Num[100024],Son[100024][2],Fa[100024];
int head[100024],Ecnt;
struct koko{int to,Ne,dis;}E[200056];
inline void add(int u,int v,int d)
{
    E[++Ecnt].to=v;E[Ecnt].Ne=head[u];E[Ecnt].dis=d;head[u]=Ecnt;
    E[++Ecnt].to=u;E[Ecnt].Ne=head[v];E[Ecnt].dis=d;head[v]=Ecnt;
}
inline void Add(int fa,int num,int pd){Son[fa][pd]=++cnt;Num[cnt]=num;Fa[cnt]=fa;}
inline int Min(int x){for(;Son[x][0];x=Son[x][0]);return x;}
inline int Max(int x){for(;Son[x][1];x=Son[x][1]);return x;}
inline void dfs(int u,int fa)
{
    dfn[u]=++Index; Rank[Index]=u; Dep[u]=Dep[fa]+1; F[u][0]=fa;
    for(int j=1;j<18;++j) F[u][j]=F[F[u][j-1]][j-1];
    for(int j=head[u];j;j=E[j].Ne)
        if(E[j].to!=fa) Dis[E[j].to]=Dis[u]+E[j].dis,dfs(E[j].to,u);
}
inline int Lca(int u,int v)
{
    if(Dep[u]<Dep[v]) Swap(u,v);
    int d=Dep[u]-Dep[v];
    for(int i=0;i<18;++i)
        if(d&(1<<i)) u=F[u][i];
    if(u==v) return u;
    for(int i=17;i>=0;--i)
        if(F[u][i]!=F[v][i]) u=F[u][i],v=F[v][i];
    return F[u][0];
}
inline void Rotate(int x)
{
    int y=Fa[x],fy=Fa[y],pd=(Son[y][1]==x);
    Son[y][pd]=Son[x][!pd]; Fa[Son[x][!pd]]=y;
    Son[x][!pd]=y; Fa[y]=x; Fa[x]=fy;
    if(fy)
    {
        if(Son[fy][0]==y) Son[fy][0]=x;
        else if(Son[fy][1]==y) Son[fy][1]=x;
    }
}
inline void Splay(int x)
{
    for(int y;y=Fa[x];Rotate(x))
        if(Fa[y]) Rotate((Son[y][0]==x)==(Son[Fa[y]][0]==y)?y:x);
    Root=x;
}
inline void splay(int x)
{
    for(int y;y=Fa[x];Rotate(x))
        if(Fa[y]!=Root && Fa[y]) Rotate((x==Son[y][0])==(y==Son[Fa[y]][0])?y:x);
    Root=x;
}
inline LL calc(int u,int v)
{
    if(!u || !v) return 0;
    u=Rank[Num[u]];v=Rank[Num[v]];
    return Dis[u]+Dis[v]-(Dis[Lca(u,v)]<<1);
}
inline void Insert(int x)
{
    int u=Root;
    for(;Son[u][Num[u]<x];u=Son[u][Num[u]<x]);
    Add(u,x,Num[u]<x); Splay(cnt);
    int pos1=0,pos2=0;
    if(Son[cnt][0]) pos1=Max(Son[cnt][0]);
    if(Son[cnt][1]) pos2=Min(Son[cnt][1]);
    Ans=Ans-calc(pos1,pos2)+calc(pos1,cnt)+calc(pos2,cnt);
}
inline int Find(int x)
{
    int u=Root,v=1;
    for(;v;u=v)
    {
        v=Son[u][Num[u]<x];
        if(Num[u]==x) return u;
    }
}
inline void Delete(int x)
{
    x=Find(x); Splay(x);
    int pos1=0,pos2=0;
    if(Son[x][0]) pos1=Max(Son[x][0]);
    if(Son[x][1]) pos2=Min(Son[x][1]);
    Ans=Ans-calc(pos1,x)-calc(pos2,x)+calc(pos1,pos2);
    if(!Son[x][0] && !Son[x][1]) {Fa[x]=0;Root=0;Son[0][0]=Son[0][1]=0;return;}
    if(Son[x][0]) {int y=Max(Son[x][0]);Splay(y);}
    else {Root=Son[x][1];Fa[Son[x][1]]=0;Son[x][1]=0;return;}
    if(Son[x][1]) {int y=Min(Son[x][1]);splay(y);}
    Son[Fa[x]][Num[Fa[x]]<Num[x]]=0;
    Fa[x]=0; Son[x][0]=Son[x][1]=0;
}
int main()
{
    scanf("%d", &N); int a,b,d; char c[8];
    for(int g=1;g<N;++g) scanf("%d%d%d", &a,&b,&d),add(a,b,d);
    dfs(1,0); scanf("%d\\n", &M);
    for(int g=1;g<=M;++g)
    {
        scanf("%s", c);
        if(c[0]==‘+‘) scanf("%d\\n",&a),Insert(dfn[a]);
        else if(c[0]==‘-‘) scanf("%d\\n",&a),Delete(dfn[a]);
        if(c[0]==‘?‘) scanf("\\n"),printf("%lld\\n", (Ans+calc(Min(Root),Max(Root)))>>1);
    }
    return 0;
}