洛谷 P4172 [WC2006]水管局长 （bzoj2594原题） 题解【LCT】【生成树】【贪心】

点击量：551

才切掉第一道LCT非裸题，窝trl。

目录

题目描述

$ \text{SC}$省$ \text{MY}$市有着庞大的地下水管网络，嘟嘟是$ \text{MY}$市的水管局长（就是管水管的啦），嘟嘟作为水管局长的工作就是：每天供水公司可能要将一定量的水从$ x$处送往$ y$处，嘟嘟需要为供水公司找到一条从$ A$至$ B$的水管的路径，接着通过信息化的控制中心通知路径上的水管进入准备送水状态，等到路径上每一条水管都准备好了，供水公司就可以开始送水了。嘟嘟一次只能处理一项送水任务，等到当前的送水任务完成了，才能处理下一项。

在处理每项送水任务之前，路径上的水管都要进行一系列的准备操作，如清洗、消毒等等。嘟嘟在控制中心一声令下，这些水管的准备操作同时开始，但由于各条管道的长度、内径不同，进行准备操作需要的时间可能不同。供水公司总是希望嘟嘟能找到这样一条送水路径，路径上的所有管道全都准备就绪所需要的时间尽量短。嘟嘟希望你能帮助他完成这样的一个选择路径的系统，以满足供水公司的要求。另外，由于$ \text{MY}$市的水管年代久远，一些水管会不时出现故障导致不能使用，你的程序必须考虑到这一点。

不妨将$ \text{MY}$市的水管网络看作一幅简单无向图（即没有自环或重边）：水管是图中的边，水管的连接处为图中的结点。

输入输出格式

输入格式：

输入文件第一行为$ 3$个整数：$ N,M,Q$分别表示管道连接处（结点）的数目、目前水管（无向边）的数目，以及你的程序需要处理的任务数目（包括寻找一条满足要求的路径和接受某条水管坏掉的事实）。

以下$ M$行，每行$ 3$个整数$ x,y$和$ tt$，描述一条对应的水管。$ x$和$ y$表示水管两端结点的编号，$ t$表示准备送水所需要的时间。我们不妨为结点从$ 1$至$ N$编号，这样所有的$ x$和$ y$都在范围$ [1,N]$内。

以下$ Q$行，每行描述一项任务。其中第一个整数为$ k$：

若$ k=1$，则后跟两个整数$ A$和$ B$，表示你需要为供水公司寻找一条满足要求的从$ A$到$ B$的水管路径；

若$ k=2$，则后跟两个整数$ x$和$ y$，表示直接连接$ x$和$ y$的水管宣布报废（保证合法，即在此之前直接连接$ x$和$ y$尚未报废的水管一定存在）。

输出格式：

按顺序对应输入文件中每一项$ k=1$的任务，你需要输出一个数字和一个回车/换行符。该数字表示：你寻找到的水管路径中所有管道全都完成准备工作所需要的时间（当然要求最短）。

输入输出样例

输入样例：

4 4 3
1 2 2
2 3 3
3 4 2
1 4 2
1 1 4
2 1 4
1 1 4

输出样例：

2
3

约定

$ N\le 1000,\quad M,Q\le 100000$

测试数据中宣布报废的水管不超过$ 5000$条；且任何时候我们考虑的水管网络都是连通的，即从任一结点$ A$必有至少一条水管路径通往任一结点$ B$。

【加强版约定】

$ N,Q\le 100000,\quad M\le 1000000$

任何时候我们考虑的水管网络都是连通的，即从任一结点$ A$必有至少一条水管路径通往任一结点$ B$。

题解：

这个题要维护的是一个图而不是一棵树，看似不能用LCT写。但是这是LCT的一个用法——维护生成树。

因为本题要求出路径上的最大值，可能会想到货车运输的一个贪心，并维护生成树。然而还需要动态删边，万一删掉了生成树上的边，总不能再做一遍生成树吧？

但是这个题只有删边，因此过程是单调的，因此把它倒过来就是加边。加边理论上就好做一些了。

因为保证了“任何时候我们考虑的水管网络都是连通的”，所以先把图删到最后，不做任何查询操作，这一点又有点像航线规划一题了（这题以前是用树剖水过去的，也是先把边删完）。

此时我们求出残余图上的最小生成树，那么任意两点之间只要沿着这棵MST上走，就是最优的，这是一个贪心。

拿LCT维护这棵生成树，splay上的点维护的是区间最大值，本质上是一条链的最大权值。

之后考虑加边，也就是动态的MST了，顺着上面贪心的思路想，如果在树上加入一条边，就会形成一个环。此时从任意一点进入环，从另一点出环，可以从环上两个方向走，那么最优解总可以避开最长的一条边。

比如说从$ E$到$ D$，最优的路径是$ E-C-A-B-D$，路径最大值为$ 7$，而$ E-F-D$最大值为$ 8$。那么$ D-F$这条边可以删掉，原因是最优解总不必经过这条边。

那么假设$ E-F$这条边是新加进来的，原来的图是这样（“环”上的点还连接有其他的边，但保证是一棵树）

我们现在只关注这个“环”，先用split(E,F)把$ E-F$这条链的信息提取出来。此时可以查询出链上的最大权值$ 8$，与即将加入的$ 3$进行比较。发现$ 3<8$。说明这个环上可以删掉权值最大的边来保证最优，那么在平衡树上“二分”出这条边，来删除它。如果即将加入的边权比整条链上的最大值还大，那么直接忽略这个操作。

上面提到的“二分”实际上是在平衡树上查找。如果发现根节点的值就是所要的值，就返回根节点，否则哪棵子树中有这个最大值，就进哪棵子树，这一步复杂度均摊$ O(\log n)$。

查询的时候直接split()然后查询链的信息就好了。

还有一个重要的是如何维护边，这时不能像树剖那样维护到父亲的边了。因为LCT比较灵活，所以考虑用一个点来代表一条边。比如说我要连接原图上的$ 1,2$两点，把这条边命名为$ A$（$ A$在程序中还是会用数字来表示的），权值为$ 4$。

就把$ 1,2$与$ A$分别连接起来。$ A$在整张图中始终只与$ 1,2$这两个点相连，边权在LCT上表示为点权。原图上的点点权为$ 0$（如果要求最小值原图上的点应该设为$ +\infty$）。

然后倒序加边，再把答案倒过来输出就可以了。

加强版tips：

$ f[i][j]$表示连接$ i,j$的边编号是多少，用来确定删掉的是哪条边。此时$ N\le 10^5$，只能用std::map了，常数略微有点大。再加入快读就能通过。

Code：(普通版)

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ls ch[0][k]
#define rs ch[1][k]
#define which(k) (ch[1][fa[k]]==k)
#define isroot(k) (ch[0][fa[k]]!=k&&ch[1][fa[k]]!=k)
using std::max;
int ch[2][120000],fa[120000];
int key[120000],sum[120000],lazy[120000];
void maintain(int k)
{
    sum[k]=max(max(sum[ls],key[k]),sum[rs]);
}
void pushdown(int k)
{
    if(lazy[k])
    {
        int tmp=ls;
        ls=rs;
        rs=tmp;
        lazy[k]=0;
        lazy[ls]^=1;
        lazy[rs]^=1;
    }
}
void Rotate(int k)
{
    int y=fa[k];
    if(!isroot(y))
        ch[which(y)][fa[y]]=k;
    bool d=which(k);
    fa[k]=fa[y];
    fa[y]=k;
    ch[d][y]=ch[!d][k];
    fa[ch[d][y]]=y;
    ch[!d][k]=y;
    maintain(y);
    maintain(k);
}
int stk[120000],tp=0;
void splay(int k)
{
    int x=k;
    while(!isroot(x))
    {
        stk[++tp]=x;
        x=fa[x];
    }
    stk[++tp]=x;
    while(tp)
        pushdown(stk[tp--]);

    while(!isroot(k))
    {
        int y=fa[k];
        if(!isroot(y))
            Rotate(which(k)^which(y)?k:y);
        Rotate(k);
    }
}
void access(int k)
{
    for(int x=k,y=0;x;y=x,x=fa[x])
    {
        splay(x);
        ch[1][x]=y;
        maintain(x);
    }
}
void makeroot(int k)
{
    access(k);
    splay(k);
    lazy[k]^=1;
}
void split(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
}
void link(int x,int y)
{
    makeroot(x);
    fa[x]=y;
}
void cut(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
    fa[x]=ch[0][y]=0;
}
int Find(int k,int x)
{
    if(key[k]==x)
        return k;
    if(sum[ls]==x)
        return Find(ls,x);
    return Find(rs,x);
}
int f[1010][1010],U[101000],V[101000],op[101000];
int n,m,q;
struct edge
{
    int x,y,v,ava;
    edge(){ava=1;}
    friend bool operator <(edge a,edge b)
    {
        return a.v<b.v;
    }
}e[101000];
int s[1010];
int Find(int x)
{
    if(s[x]!=x)
        return s[x]=Find(s[x]);
    return x;
}
void Union(int x,int y)
{
    s[Find(x)]=Find(y);
}
void mst()
{
    for(int i=1;i<=n;++i)
        s[i]=i;
    for(int i=1;i<=m;++i)
        if(e[i].ava&&Find(e[i].x)!=Find(e[i].y))
        {
            Union(e[i].x,e[i].y);
            link(e[i].x,n+i);
            link(e[i].y,n+i);
        }
}
int ans[101000];
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=m;++i)
        scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].v);
    std::sort(e+1,e+1+m);
    for(int i=1;i<=m;++i)
    {
        f[e[i].x][e[i].y]=f[e[i].y][e[i].x]=i;
        key[n+i]=e[i].v;
    }
    for(int i=1;i<=q;++i)
    {
        scanf("%d%d%d",&op[i],&U[i],&V[i]);
        if(op[i]==2)
            e[f[U[i]][V[i]]].ava=0;
    }
    mst();
    int cnt=0;
    for(int i=q;i>=1;--i)
    {
        split(U[i],V[i]);//V[i]是根
        if(op[i]==1)
            ans[++cnt]=sum[V[i]];
        else
        {
            int t=Find(V[i],sum[V[i]]);
            if(key[f[U[i]][V[i]]+n]<sum[V[i]])
            {
                cut(e[t-n].x,t);
                cut(e[t-n].y,t);
                link(U[i],f[U[i]][V[i]]+n);
                link(V[i],f[U[i]][V[i]]+n);
            }
        }
    }
    for(int i=cnt;i>=1;--i)
        printf("%d\n",ans[i]);
    return 0;
}