对原图进行边双通缩点,得到一棵树,两点间的关键航线就是这两点在这棵树上经过的树边的数量。
询问中涉及到删边,显然不可能每删一次都重现跑tarjan来维护这棵树,考虑倒着做,对最后的图进行缩点建树。
对树上的边附上边权,每条边的边权为 1,查询时就输出路径的边权之和,当连接一条边时 (x,y), 构造一个环, 之间的路径都不再是树上的边,将路径上的边权置为 0,不需要修改树形,对 连边。
这个过程很容易想到用树剖进行维护,考虑 LCT 怎么做。
LCT 同样可以维护边权,直接维护不容易维护,因为 LCT 的辅助树树形会不断变化,对应的 splay 就不断变化。将每条边抽象成一个点,每条边拆成两条边,例如(x,y) 拆成(x,z),(z,y)。这样只要维护 点权 信息。
考虑对 splay 中每个节点维护一个子树和,查询时将路径提取出来查询根节点的 子树和即可。当某条边加入后会形成环时,就将整颗子树的节点权值清0,打个标记即可。
写 LCT 的时候可以不用跑一遍 tarjan, LCT 在建图的过程中就可以维护连通性,当某条边加入后会出现环时就直接打标记维护。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
typedef long long ll;
#define pii pair<int,int>
#define fir first
#define sec second
int n,m,res[maxn];
vector<int> g[maxn];
map<pii,int> mp;
pii E[maxn];
inline int read(){
int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}
struct node {
int c,ans,x,y;
node(int ci = 0,int a = 0,int xi = 0,int yi = 0) {
c = ci; ans = a; x = xi; y = yi;
}
}q[maxn];
struct LCT { //用splay维护原森林的连通,用到了splay的操作以及数组
int ch[maxn][2]; //ch[u][0] 表示 左二子,ch[u][1] 表示右儿子
int f[maxn]; //当前节点的父节点
int tag[maxn]; //翻转标记,乘标记,加标记
int top,sta[maxn],sz[maxn];
int laz[maxn],val[maxn],sum[maxn];
inline bool get(int x) {
return ch[f[x]][1] == x;
}
void init() {
memset(f,0,sizeof f);
memset(ch,0,sizeof ch);
memset(tag,0,sizeof tag);
memset(laz,0,sizeof laz);
}
inline void pushup(int rt) {
if (rt) {
sz[rt] = 1; sum[rt] = val[rt];
int ls = ch[rt][0], rs = ch[rt][1];
if (ls) {
sz[rt] += sz[ls];
sum[rt] += sum[ls];
}
if (rs) {
sz[rt] += sz[rs];
sum[rt] += sum[rs];
}
}
}
inline void pushdown(int rt) {
if (tag[rt]) {
int ls = ch[rt][0], rs = ch[rt][1];
if (ls) swap(ch[ls][0],ch[ls][1]), tag[ls] ^= 1;
if (rs) swap(ch[rs][0],ch[rs][1]), tag[rs] ^= 1;
tag[rt] = 0;
}
if (laz[rt]) {
int ls = ch[rt][0], rs = ch[rt][1];
if (ls) {
val[ls] = sum[ls] = 0;
laz[ls] = 1;
}
if (rs) {
val[rs] = sum[rs] = 0;
laz[rs] = 1;
}
laz[rt] = 0;
}
}
inline bool isroot(int x) {
return (ch[f[x]][0] != x) && (ch[f[x]][1] != x);
}
inline void rotate(int x) { //旋转操作,根据 x 在 f[x] 的哪一侧进行左旋和右旋
int old = f[x], oldf = f[old];
int whichx = get(x);
if(!isroot(old)) ch[oldf][ch[oldf][1] == old] = x; //如果 old 不是根节点,就要修改 oldf 的子节点信息
ch[old][whichx] = ch[x][whichx ^ 1];
ch[x][whichx ^ 1] = old;
f[ch[old][whichx]] = old;
f[old] = x; f[x] = oldf;
pushup(old); pushup(x);
}
inline void splay(int x) { //将 x 旋到所在 splay 的根
top = 0; sta[++top] = x;
for (int i = x; !isroot(i); i = f[i]) sta[++top] = f[i]; //在 splay 中维护 下推标记
while(top) pushdown(sta[top--]);
for(int fa = f[x]; !isroot(x); rotate(x), fa = f[x]) { //再把x翻上来
if(!isroot(fa)) //如果fa非根,且x 和 fa是同一侧,那么先翻转fa,否则先翻转x
rotate((get(x) == get(fa)) ? fa : x);
}
}
inline void access(int x) { //access操作将x 到 根路径上的边修改为重边
int lst = 0;
while(x > 0) {
splay(x);
ch[x][1] = lst;
pushup(x);
lst = x; x = f[x];
}
}
inline void move_to_root(int x) { //将 x 移到 x 所在树的根(不是所在splay的根,所在splay只是一条重链)
access(x); splay(x); tag[x] ^= 1; swap(ch[x][0],ch[x][1]);
//将 x 移到 根之后 x 是深度最低的点,这条重链、这棵splay上所有点的深度颠倒,
//所有的点的左子树的点应该到右子树,因此要翻转这棵splay的左右子树
}
inline int findroot(int x) {
access(x);
splay(x);
int rt = x;
while(ch[rt][0]) rt = ch[rt][0];
return rt;
}
inline void link(int x,int y) {
move_to_root(x); f[x] = y; splay(x);
}
inline void cut(int x,int y) {
move_to_root(x); access(y);
splay(y); ch[y][0] = f[x] = 0;
pushup(y);
}
}tree;
int x,y,u,v,k[maxn],tot,vis[maxn];
char op[10];
int main() {
n = read(); m = read();
for (int i = 1; i <= m; i++) {
u = read(); v = read();
if (u > v) swap(u,v);
E[i] = pii(u,v);
mp[E[i]] = i + n;
tree.val[i + n] = 1;
}
while (1) {
int c = read();
if (c == -1) break;
u = read(); v = read();
if (u > v) swap(u,v);
q[++tot] = node(c,0,u,v);
if (!c) vis[mp[pii(u,v)]] = 1;
}
for (int i = 1; i <= m; i++) {
if (vis[mp[E[i]]]) continue;
if (tree.findroot(E[i].fir) != tree.findroot(E[i].sec)) {
tree.link(E[i].fir,i + n);
tree.link(E[i].sec,i + n);
} else {
tree.move_to_root(E[i].fir);
tree.access(E[i].sec);
tree.splay(E[i].sec);
tree.sum[E[i].sec] = tree.val[E[i].sec] = 0;
tree.laz[E[i].sec] = 1;
}
}
for (int i = tot; i >= 1; i--) {
int u = q[i].x, v = q[i].y;
if (!q[i].c) {
if (tree.findroot(u) != tree.findroot(v)) {
tree.link(u,mp[pii(u,v)]);
tree.link(v,mp[pii(u,v)]);
} else {
tree.move_to_root(u);
tree.access(v);
tree.splay(v);
tree.sum[v] = tree.val[v] = 0;
tree.laz[v] = 1;
}
} else {
tree.move_to_root(u);
tree.access(v);
tree.splay(v);
q[i].ans = tree.sum[v];
}
}
for (int i = 1; i <= tot; i++)
if (q[i].c) printf("%d\n",q[i].ans);
return 0;
}