BZOJ 2594: [Wc2006]水管局长数据加强版(LCT+最小生成树+离线)

题目戳我

---

Solution

题目大意：就是让你维护一棵动态的最小生成树， 并询问两点路径中边权最大值。

很明显，用LCT来做这个。有几个关键点：
①删边维护mst不好搞，我们离线然后删边变加边。
②一开始用kruskal搞出底图的mst，然后加边，判断一条路径的最大值是否大于当前边的长度，是就替换掉原先的边。因为这样答案肯定不会差。
③注意答案的保存及下标的转换等大量细节。
④一开始建底图时找出有用的边用排序+二分查找，打上标记。
⑤LCT不要写错，否则就完了。
⑥本人的LCT自带巨大常数，所以我用了很多底层优化。诸如register，inline，位运算。。。。还有，一开始构mst时要注意，注意。。。
⑦忘记说了，本题将边当成点储存，一条边拆成两条，所以点数为n+m，所以写不好(没有⑥)就会TLE。。。

另外，我们证明(kou hu)一下为什么是求mst。首先容易发现按题目得到一个图。一开始我想了很久如何在这个图上搞事情，后来发现其实离线维护mst就可以了。因为两点之间的路径的最小的最大边一定在这个连通图的mst上。反证一下，假如不在，那么将这个“最小的最大边”替换掉mst中的那条唯一路径上的“不够优秀的最大边”换掉，mst肯定会更加的mst。就是说如果解不在mst上，那么它理应在mst上。所以它一定本来就在mst上。(以上纯属博主乱扯)

然后我们用常数巨大的LCT去应付10^6+10^5个点就可以了。重要的事情再次说一遍，不卡常数有很大风险超时。。。

下面附图佐证：

---

Code

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#define N 100010
#define M 1000010

using namespace std;

int n, m, Q, cnt;
int Ans[N];
struct Ab{int u, v, l, id;  bool f;} Edg[M], orgin[M];
struct Ever{int op, u, v, id;} oper[N];

inline int Read(){
    int x = 0;  char ch = getchar();
    while(ch < '0' || ch > '9')  ch = getchar();
    while(ch >= '0' && ch <= '9'){x = (x << 3) + (x << 1) + ch - '0';  ch = getchar();}
    return x;
}

void Print(int x){
    if(x > 9)  Print(x / 10);
    putchar(x % 10 + '0');
}

bool cmp(Ab A, Ab B){
    if(A.u ^ B.u)  return A.u < B.u;
    return A.v < B.v;
}

bool cmp__(Ab A, Ab B){
    if(!(A.f ^ B.f))  return A.l < B.l;
    return !B.f;
}

struct Tnode{
    Tnode *son[2], *fa;
    bool rev;
    int val, Max, parent, id, Maxid;
    int Get_d(){return fa->son[1] == this;}
    void Connect(Tnode *now, int d){(son[d] = now)->fa = this;}
    inline void Up(){
      Max = val;
      Maxid = id;
      if(son[0] && son[0]->Max > Max)  Max = son[0]->Max, Maxid = son[0]->Maxid;
      if(son[1] && son[1]->Max > Max)  Max = son[1]->Max, Maxid = son[1]->Maxid;
    }
    inline void Down(){
      if(rev){
        Tnode *now = son[0];
        son[0] = son[1];
        son[1] = now;
        if(son[0])  son[0]->rev ^= 1;
        if(son[1])  son[1]->rev ^= 1;
        rev = false;
      }
    }
}tree[N+M], *Node[N+M];

inline Tnode *NewTnode(int id){
    tree[cnt].rev = false;
    tree[cnt].son[0] = tree[cnt].son[1] = tree[cnt].fa = NULL;
    tree[cnt].parent = tree[cnt].val = tree[cnt].Max = 0;
    tree[cnt].Maxid = tree[cnt].id = id;
    return tree+cnt++;
}

void Zig(Tnode *now){
    Tnode *last = now->fa;
    int d = now->Get_d();
    if(now->son[!d])  last->Connect(now->son[!d], d);
    else  last->son[d] = NULL;
    if(last->fa)  last->fa->Connect(now, last->Get_d());
    else  now->fa = NULL;
    now->Connect(last, !d);
    last->Up();
    now->parent = last->parent;
    last->parent = 0;
}

void Splay(Tnode *now){
    Tnode *last;
    while(now->fa){
      last = now->fa;
      if(last->fa)  last->fa->Down();
      last->Down();  now->Down();
      if(last->fa)  (last->Get_d() ^ now->Get_d()) ? Zig(now) : Zig(last);
      Zig(now);
    }
    if(!now->fa)  now->Down();
    now->Up();
}

void Access(int x){

    Splay(Node[x]);
    if(Node[x]->son[1]){
      Node[x]->son[1]->fa = NULL;
      Node[x]->son[1]->parent = x;
      Node[x]->son[1] = NULL;
      Node[x]->Up();
    }
    int y = Node[x]->parent;
    while(y){
      Splay(Node[y]);
      if(Node[y]->son[1]){
        Node[y]->son[1]->fa = NULL;
        Node[y]->son[1]->parent = y;
        Node[y]->son[1] = NULL;
        Node[y]->Up();
      }
      Node[y]->Connect(Node[x], 1);
      Node[y]->Up();
      Node[x]->parent = 0;
      x = y;
      y = Node[x]->parent;
    }
}

void Evert(int x){
    Access(x);
    Splay(Node[x]);
    Node[x]->rev ^= 1;
}

void Link(int x, int y){
    Evert(x);
    Node[x]->parent = y;
}

void Cut(int x, int y){
    Evert(x);
    Access(y);
    Splay(Node[x]);
    Node[x]->son[1]->fa = NULL;
    Node[x]->son[1] = NULL;
    Node[x]->Up();
} 

int Find_Root(int x){
    Access(x);
    Splay(Node[x]);
    Tnode *now = Node[x];
    while(now->son[0])  now = now->son[0], now->Down();
    return now->id;
}

int main(){

    freopen("bzoj2594.in", "r", stdin);
    freopen("bzoj2594.out", "w", stdout);

    n = Read();  m = Read();  Q = Read();

    for(register int i = 1; i <= n+m; ++i)  Node[i] = NewTnode(i);
    for(register int i = 1; i <= m; ++i){
      Edg[i].u = Read();  Edg[i].v = Read();  Edg[i].l = Read();
      if(Edg[i].u > Edg[i].v)  Edg[i].u ^= Edg[i].v, Edg[i].v ^= Edg[i].u, Edg[i].u ^= Edg[i].v;
      Edg[i].f = true;
      Edg[i].id = i+n;
      Node[i+n]->val = Node[i+n]->Max = Edg[i].l;
      orgin[i] = Edg[i];
    }

    sort(Edg+1, Edg+m+1, cmp);
    for(register int i = 1; i <= Q; ++i){
      oper[i].op = Read();  oper[i].u = Read();  oper[i].v = Read();
      if(oper[i].u > oper[i].v)   oper[i].u ^= oper[i].v, oper[i].v ^= oper[i].u, oper[i].u ^= oper[i].v;
      int L = 1, R = m, mid;
      while(L <= R){
        mid = (L + R) >> 1;
        if(Edg[mid].u == oper[i].u && Edg[mid].v == oper[i].v){
          if(oper[i].op == 2)  Edg[mid].f = false;
          oper[i].id = Edg[mid].id;
          break;
        }
        if(Edg[mid].u < oper[i].u || (Edg[mid].u == oper[i].u && Edg[mid].v < oper[i].v))  L = mid + 1;
        else  R = mid - 1;
      }
    }
    sort(Edg+1, Edg+m+1, cmp__);

    for(register int i = 1; i < n; ++i){
      int a = Edg[i].u, b = Edg[i].v;
      int x = Find_Root(a), y = Find_Root(b);
      if(x ^ y){
        Link(a, Edg[i].id);
        Link(Edg[i].id, b);
      }
      else{
        Evert(a);
        Access(b);
        Splay(Node[a]);
        int id = Node[a]->Maxid;
        if(Node[a]->Max > Edg[i].l){
          Cut(orgin[id-n].u, id);
          Cut(id, orgin[id-n].v);
          Link(a, Edg[i].id);
          Link(Edg[i].id, b);
        }
      }
    }

    for(register int i = Q; i; --i){
      int a = oper[i].u, b = oper[i].v;
      int x = Find_Root(a), y = Find_Root(b);
      if(oper[i].op == 1){
        Evert(a);
        Access(b);
        Splay(Node[a]);
        Ans[++Ans[0]] = Node[a]->Max;
      }
      else{
        if(x ^ y){
          Link(a, oper[i].id);
          Link(oper[i].id, b);
        }
        else{
          Evert(a);
          Access(b);
          Splay(Node[a]);
          int id = Node[a]->Maxid;
          if(Node[a]->Max > orgin[oper[i].id-n].l){
            Cut(orgin[id-n].u, id);
            Cut(id, orgin[id-n].v);
            Link(a, oper[i].id);
            Link(oper[i].id, b);
          }
        }
      }
    }

    for(register int i = Ans[0]; i; --i){
      Print(Ans[i]);
      putchar('\n');
    }
    return 0;
}

---

世界以痛吻我 我却报之以歌