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

作者: wjyyy 分类: LCT,生成树,解题报告,贪心 发布时间: 2019-01-03 19:06

点击量:108

才切掉第一道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;
}

3
说点什么

avatar
3 Comment threads
0 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
1 Comment authors
wjyyy Recent comment authors
  Subscribe  
最新 最旧 得票最多
提醒
trackback

[…] 这里要注意的是边有边权,详细处理方法写在题解里了。 […]

trackback

[…] 化点为边的操作在这篇博客里讲的有。 […]

/* */