题意
有 $n$ 个点,初始没有连边,要求支持两个动态操作:
1. 加一条边(保证之前两点不连通)
2. 查询过一条边的简单路径数量(就是两边连通块的大小的乘积)
$n,Q\le 100000$
题解
由第一个操作保证之前两点不连通的性质可知,$n$ 个点最多被连成一棵 $n-1$ 条边的生成树。
离线做法:树剖+树状数组/线段树
我们可以离线确定出最终森林的形态(我们给森林中的每棵树随便定义个根)。
然后重新模拟操作时,只需要在最终的森林上做一些链操作(统计答案用)。
由于只有加边操作,所以模拟加边时,用并查集维护连通树及当前连通树的根。
当前连通树的根就是在加一些边后,一个点所在连通树的深度最小的点,这个深度根据最终这棵树的形态而定,越靠近根深度越小。
同时我们还要维护当前以每个点为根的子树的大小。
这样,插入一条边时,假设在最终的树形态中 $u$ 是 $v$ 的父亲(这个是已知的,因为我们随便定了一个根),那我们在合并两个连通树时,把 $v$ 所在并查集连向 $u$ 所在并查集。
由于并查集只维护连通树的根,我们要把从 $u$ 到其所在连通树的当前根的所有点都更新子树大小。
画个图
现在有一条边要连通如图两棵子树
那么所有橙色点(即u到根的路径)都要更新子树大小
根据最终树的形态来确定 $u$、$v$ 的合并方向,就是为了在维护连通性的同时维护连通树的根。之前说过,连通树的根是 在树的最终形态中深度最小的点,如果 $u$ 是 $v$ 的父亲,那 $u$ 的深度当然比 $v$ 小,应该让 $v$ 的并查集连向 $u$ 的。
这样,我们实际上就是一边加边、一边维护每个点的子树大小。
加边不用实际加,只要连并查集就行了,因为在加边时,只有从其一端点 到它所在连通树的根 上的所有点要修改,路径的两端点都已知,直接树链剖分就行了。
查询……那两个点的子树 $size$ 都已知了,而且一个点还是另一个点的父亲,(设 $x$ 是 $y$ 的父亲,$rt$ 是 $x,y$ 两点所在连通树的根)答案就是 $size_y\times (size_{rt}-size_y)$。
$size_y$ 就是 $y$ 这边的点数,$size_{rt}-size_y$ 就是 $x$ 这边的点数。
画个图就是
时间复杂度 $O(n + q\times log^2(n))$。
注:我没写这种方法,这是 $luogu$ 大佬的代码,其中的 $iota(f + 1, f + n + 1, 1);$ 就是 $for(int\space i=1;i<=n;++i)\space f[i]=i;$,即从 $1$ 开始以 $1$ 的斜率递增并依次赋值。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include <cstdio> 2 3 #include <algorithm> 4 #include <numeric> 5 6 using namespace std; 7 8 struct edge { 9 int v; 10 edge* next; 11 }; 12 13 const int N = 100010; 14 15 int n; 16 char opt[N]; 17 int eu[N], ev[N], p[N], f[N], son[N], sum[N], fw[N], ord[N]; 18 int top[N]; 19 edge* g[N]; 20 21 int find(int x); 22 void add_edge(int u, int v); 23 void dfs1(int u); 24 void dfs2(int u); 25 void change(int k, int x); 26 void tchange(int u, int x); 27 int query(int k); 28 int low_bit(int k); 29 30 int main() { 31 int q; 32 scanf("%d%d", &n, &q); 33 for (int i = 1; i <= q; ++i) { 34 scanf(" %c%d%d", &opt[i], &eu[i], &ev[i]); 35 if (opt[i] == 'A') { 36 add_edge(eu[i], ev[i]); 37 add_edge(ev[i], eu[i]); 38 } 39 } 40 for (int u = 1; u <= n; ++u) 41 if (!p[u]) { 42 p[u] = -1; 43 dfs1(u); 44 } 45 for (int u = 1; u <= n; ++u) 46 if (p[u] == -1) { 47 top[u] = u; 48 dfs2(u); 49 } 50 iota(f + 1, f + n + 1, 1); 51 for (int i = 1; i <= n; ++i) { 52 tchange(i, 1); 53 tchange(p[i], -1); 54 } 55 for (int i = 1; i <= q; ++i) { 56 int u = eu[i], v = ev[i]; 57 if (p[u] == v) 58 swap(u, v); 59 int sv = query(ord[v]); 60 if (opt[i] == 'A') { 61 f[v] = find(u); 62 tchange(u, sv); 63 tchange(p[f[u]], -sv); 64 } else { 65 int s = query(ord[find(u)]); 66 printf("%d\n", (s - sv) * sv); 67 } 68 } 69 return 0; 70 } 71 72 void tchange(int u, int x) { 73 while (u != -1) { 74 change(ord[top[u]], x); 75 change(ord[u] + 1, -x); 76 u = p[top[u]]; 77 } 78 } 79 80 void dfs2(int u) { 81 static int t; 82 ord[u] = ++t; 83 if (!son[u]) 84 return; 85 top[son[u]] = top[u]; 86 dfs2(son[u]); 87 for (edge* q = g[u]; q; q = q->next) 88 if (p[q->v] == u && q->v != son[u]) { 89 top[q->v] = q->v; 90 dfs2(q->v); 91 } 92 } 93 94 int low_bit(int k) { 95 return k & -k; 96 } 97 98 void change(int k, int x) { 99 for (; k <= n; k += low_bit(k)) 100 fw[k] += x; 101 } 102 103 int query(int k) { 104 int ret = 0; 105 for (; k; k -= low_bit(k)) 106 ret += fw[k]; 107 return ret; 108 } 109 110 void dfs1(int u) { 111 sum[u] = 1; 112 for (edge* q = g[u]; q; q = q->next) 113 if (!p[q->v]) { 114 p[q->v] = u; 115 dfs1(q->v); 116 sum[u] += sum[q->v]; 117 if (sum[son[u]] < sum[q->v]) 118 son[u] = q->v; 119 } 120 } 121 122 int find(int x) { 123 return f[x] == x ? x : (f[x] = find(f[x])); 124 } 125 126 void add_edge(int u, int v) { 127 static edge pool[N * 2]; 128 static edge* p = pool; 129 p->v = v; 130 p->next = g[u]; 131 g[u] = p; 132 ++p; 133 }
在线做法:LCT
$LCT$ 由于使用 $splay$ 维护一条链,但 $splay$ 的中序遍历才是链从上往下的顺序,形态不一样(同一点在 $splay$ 的子树和在原树中的子树也不一样),所以 $splay$ 没法直接维护原树的子树信息。
但对于某些题来说,可以做一些“假的”维护子树信息。
对于这题,即使询问边的两端点 $x,y$ 是相邻的,我们也可以 $split$ 出 $x$ 到 $y$ 的只有一条边的路径。
这里复习一下 $split(x,y)$ 是干嘛来着。
首先 $makeroot(x)$,即 $x$ 成了其所在 $splay$ 的根,且它没有左子树。
然后 $access(y)$,由于 $x$ 和 $y$ 本来就相邻,那么两点间就连了条重边,两点连出的其余所有边都变成轻边。
最后 $splay(y)$,$y$ 成了这个 $splay$ 的根,$x$ 成了 $y$ 的左儿子 且 $x$ 没有儿子。
也就是说,$split(x,y)$ 后,就成了这样子
那这俩点所在的 $splay$ 就只剩这 $2$ 个点了!(详见 $access$)
而且两点连出去的其它边都是轻边!
我们知道,轻边不是用 $splay$ 维护的,所以我们可以 $fake$ 一下,装作维护子树信息,其实是维护每个点的所有轻儿子的子树信息。
轻儿子的信息分这么几个部分维护:
1. 做某些操作时,对于一个点的所有儿子,一条边变重后,原来的重边变成轻边,所以这个点的轻子树大小总和 $lit$ 减去变重的儿子的 $size$,加上变轻的儿子的 $size$。
2. 加边时($link(x,y)$),由于 $split(x,y)$,$y$ 会变成 $x$ 的父亲,且两点间连上重边,所以 $y$ 的 $lit$ 加上 以 $x$ 为根的子树的 $size$。
3. $splay$ 做 $pushup$ 时别忘了把 $size$ 值加上其 $lit$。本来 $LCT$ 的 $splay$ 是不维护轻子树信息的,这里为了最后的查询,可以直接加上它们(比较方便)。
查询时,实际上就是查询 $x$ 的所有轻儿子的子树大小总和。由于 $x$ 没有重儿子,它的 $size$ 值实际上就是它本身和所有轻子树大小的总和,也就是 $x$ 这边的答案。
$y$ 那边的答案就是 $size_y-size_x$。
原来这类题还可以直接把 $size$ 加上轻儿子的信息……
最后说一个我做题时混淆了的概念:
如果连一条边会影响一端点及其所有祖先的信息(比如子树 $size$ 值,连边时就会影响点 $y$ 及其所有祖先),那 $link(x,y)$ 时不能只 $makeroot(x)$(把 $x$ 设成其所在的树的根,然后修改其父亲为 $y$,$y$ 的位置其实无所谓),而要 $split$ 出这两点的路径(也就是说要把 $y$ 转到整棵树根)。
因为 $LCT$ 只保证了每棵 $splay$ 的深度是 $log$ 级别的,没有保证整棵树的深度,也就是说如果不把 $y$ 设成根,把 $y$ 一直 $pushup$ 到整棵树的根等于做暴力,复杂度不对。
时间复杂度 $O(n+q\times log(n))$。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h> 2 #define rep(i,x,y) for(int i=x;i<=y;++i) 3 #define dwn(i,x,y) for(int i=x;i>=y;--i) 4 #define ll long long 5 #define N 100002 6 using namespace std; 7 inline int read(){ 8 int x=0; bool f=1; char c=getchar(); 9 for(;!isdigit(c);c=getchar()) if(c=='-') f=0; 10 for(; isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+(c^'0'); 11 if(f) return x; 12 return 0-x; 13 } 14 int n,m,siz[N],son[N][2],fa[N],lit[N]; //lit维护一个点的所有轻边连向的子树 15 bool rev[N]; 16 namespace LCT{ 17 inline bool dir(int x){return son[fa[x]][1]==x;} 18 inline bool isroot(int x){return son[fa[x]][0]!=x && son[fa[x]][1]!=x;} 19 inline void pushup(int x){siz[x]=siz[son[x][0]]+siz[son[x][1]]+lit[x]+1;} 20 inline void pushdown(int x){ 21 if(rev[x]) 22 swap(son[x][0],son[x][1]), rev[son[x][0]]^=1, rev[son[x][1]]^=1, rev[x]=0; 23 } 24 inline void rotate(int x){ 25 int f,ff,k; f=fa[x],ff=fa[f],k=dir(x); 26 fa[x]=ff; if(!isroot(f)) son[ff][dir(f)]=x; 27 son[fa[son[x][k^1]]=f][k] = son[x][k^1]; 28 son[fa[f]=x][k^1]=f; 29 pushup(f), pushup(x); 30 } 31 inline void splay(int x){ 32 int sta[N],top,f; 33 for(int i=x,top=0;!isroot(i);i=fa[i]) sta[top--]=i; 34 for(;top;pushdown(sta[--top])); 35 for(f=fa[x];!isroot(x);rotate(x),f=fa[x]) 36 if(!isroot(f)) rotate(dir(f)==dir(x)?f:x); 37 } 38 inline void access(int x){ 39 for(int s=0,f=x; f; s=f,f=fa[f]){ 40 splay(f); 41 lit[f]+=siz[son[f][1]]-siz[s]; //f与s间连上了重边,与原来f的重儿子(即splay中f的右儿子)连上了轻边,由于是维护轻子树信息,所以要加一个、减一个。 42 //printf("%d %d %d\n",s,f,lit[f]); 43 if(lit[f]<0) printf("err\n"); 44 son[f][1]=s, pushup(f); 45 } 46 } 47 inline void makeroot(int x){access(x),splay(x),rev[x]^=1;} 48 inline void split(int x,int y){makeroot(x),access(y),splay(y);} 49 inline void link(int x,int y){split(x,y),fa[x]=y; lit[y]+=siz[x],pushup(y);} 50 inline ll query(int x,int y){split(x,y); return 1ll*siz[x]*(siz[y]-siz[x]);} 51 } 52 using namespace LCT; 53 int main(){ 54 n=read(),m=read(); 55 rep(i,1,n) siz[i]=1; 56 char opt[2]; int x,y; 57 rep(i,1,m){ 58 scanf("%s",opt); x=read(),y=read(); 59 if(opt[0]=='A') link(x,y); 60 else printf("%lld\n",query(x,y)); 61 } 62 return 0; 63 }