LCT例题·BZOJ2049洞穴勘测、BZOJ3669魔法森林

最新推荐文章于 2021-09-06 14:00:51 发布

原创最新推荐文章于 2021-09-06 14:00:51 发布 · 541 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LCT

题解同时被 3 个专栏收录

150 篇文章

订阅专栏

数据结构 & 图论

64 篇文章

订阅专栏

LCT

4 篇文章

订阅专栏

本文介绍了LCT算法在解决洞穴勘测与魔法森林等问题中的应用。通过实例详细讲解了LCT的基本操作及其在处理动态连通性和寻找最优路径问题中的实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LCT例题·BZOJ2049洞穴勘测、BZOJ3669魔法森林

LCT是个好东西。

BZOJ2049洞穴勘测

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=2049

题意：
n个点m个操作,操作有三种
1.Connect 连接两个点；
2.Destroy 删除两个点之间的连接；
3.Query 查询两个点是否连通；

题解：
LCT入门，只有几个基础操作
%黄学长
代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=10005;
struct node
{
    int fa,ch[2];
    bool rez;   
};
node tr[N];
int n,m;
struct Link_Cut_Tree
{
    void init(int x)
    {
        tr[x].fa=tr[x].ch[0]=tr[x].ch[0]=0; tr[x].rez=0;
    }
    bool isroot(int x)       //是否是该条链的splay的root 
    {
        return (tr[tr[x].fa].ch[0]!=x)&&(tr[tr[x].fa].ch[01]!=x);
    }
    void pushdown(int x)
    {
        if(tr[x].rez)
        {
            swap(tr[x].ch[0],tr[x].ch[1]);
            tr[x].rez^=1; tr[tr[x].ch[0]].rez^=1; tr[tr[x].ch[1]].rez^=1;
            return;
        }
    }
    void push(int x)
    {
        if(!isroot(x)) push(tr[x].fa);
        pushdown(x);
    }
    void rotate(int x)
    {
        int y=tr[x].fa; int z=tr[y].fa;
        int l,r;
        if(tr[y].ch[0]==x) l=0; else l=1; r=l^1;
        if(!isroot(y))
        {
            if(tr[z].ch[0]==y) tr[z].ch[0]=x; else tr[z].ch[1]=x;
        }
        tr[y].ch[l]=tr[x].ch[r]; tr[x].ch[r]=y; 
        tr[x].fa=z; tr[y].fa=x; tr[tr[y].ch[l]].fa=y;
    //  update(y); update(x);
    }
    void splay(int x)
    {
        push(x);
        while(!isroot(x))
        {
            int y=tr[x].fa; int z=tr[y].fa;
            if(!isroot(y))
            {
                if((tr[z].ch[0]==y)^(tr[y].ch[1]==x))   rotate(y);////////zag
                else rotate(x);/////////////zig
            }
            rotate(x);
        }
    }
    void access(int x)
    {
        int y=0;
        for(;x;y=x,x=tr[x].fa)
        {
            splay(x);
            tr[x].ch[1]=y;//y的深度>x，y成为x的右儿子 
            //update(x);
        }
    }
    int findroot(int x)
    {
        access(x); splay(x);
        while(tr[x].ch[0]) x=tr[x].ch[0];
        return x;
    }
    void rever(int x)
    {
        access(x); splay(x); tr[x].rez^=1;
    }
    void link(int x,int y)
    {
        if(findroot(x)==findroot(y)) {puts("-1");return;}
        rever(x); tr[x].fa=y;
    }
    void cut(int x,int y)
    {
        if(findroot(x)!=findroot(y)) {puts("-1");return;}
        rever(x); access(y); splay(y);       //先把X搞成根了 所以深度较小 
        tr[y].ch[0]=tr[x].fa=0; //update(y);////////////
    }
    void query(int x,int y)
    {
        if (findroot(x)==findroot(y)) printf("Yes\n");
        else printf("No\n");
    }
}LCT;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n;i++)
    {
        LCT.init(i);
    }
    while(m--)
    {
        char opt[10]; int u,v;
        scanf("%s",opt); scanf("%d%d",&u,&v);
        if(opt[0]=='C')
        {
            LCT.link(u,v);
        }
        else if(opt[0]=='D')
        {
            LCT.cut(u,v);
        }
        else
        LCT.query(u,v); 
    }
    return 0;
}

BZOJ3669魔法森林

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=2049

题意：给定一个图，每条边有ai、bi两种路径，选择一条1~n的路径，使得这条路径上max（ai）+max（bi）最小。

题解：这道题非常妙的一点在于把边看做一个点，连接着这条边的左右端点。
其次，先把ai排序，按照类似与做最小生成树的方法依次添加，若左右端点未联通，则直接link(端点u，代表边的节点)、link(端点v，代表边的节点)。若联通，则判断当前u-v路径上的最大bi值是否大于当前bi，若是，断原边，连现边。当达到1~n连通后，每次比较当前ans与记录的最小ans即可。
之前为什么更新时是直接比较b值有些不理解，其实是这样：

考虑直接用比较b值的正确性:
1、如果加入这条边前1，N不连通，则后面一定会加入边，由于a值递增，后面的a值比现在两条边的a 值都要大，因此当前边的a值大小不会影响。
2、如果加入这条边前1，N已联通，则之前的最小答案已经记录，不会对最终答案进行影响。

ps.这里学长对ai<=30,bi<=50000的子问题给了个思路，固定一个量，枚举ai,对满足条件的边的bi构造最小生成树。

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=50005;
const int M=100005;
int val[M+N];
const int inf=0x7fffffff;
int ans;
struct eadge
{
    int u,v,a,b;
}e[M];
bool cmp(const eadge &A,const eadge &B)
{
    return A.a<B.a;
}
struct node
{
    int ch[2],fa;
    int pos,maxn;
    bool rev;
};
node tr[M+N];
struct Link_Cut_Tree
{
    void init(int x)
    {
        tr[x].fa=tr[x].ch[0]=tr[x].ch[1]=tr[x].pos=tr[x].maxn=tr[x].rev=0;
    }
    void pushdown(int x)
    {
        if(!x) return;
        if(tr[x].rev)
        {
            swap(tr[x].ch[0],tr[x].ch[1]);
            tr[tr[x].ch[0]].rev^=1;
            tr[tr[x].ch[1]].rev^=1;
            tr[x].rev^=1;
        }
    }
    void push(int x)
    {
        if(!isroot(x)) push(tr[x].fa);
        pushdown(x);        
    }
    void update(int x)
    {
        if(!x) return;
        tr[x].pos=x;    tr[x].maxn=val[x]; //因为其左右子树都有可能更改，因此不能根据ch[0/1]更改，而是从自己val开始 
        if(tr[x].ch[0])  
            if(val[tr[x].pos]<val[tr[tr[x].ch[0]].pos]) {tr[x].maxn=tr[tr[x].ch[0]].maxn; tr[x].pos=tr[tr[x].ch[0]].pos;}              
        if(tr[x].ch[1])
            if(val[tr[x].pos]<val[tr[tr[x].ch[1]].pos]) {tr[x].maxn=tr[tr[x].ch[1]].maxn; tr[x].pos=tr[tr[x].ch[1]].pos;}   
    }
    bool isroot(int x)
    {
        return (tr[tr[x].fa].ch[0]!=x)&&(tr[tr[x].fa].ch[1]!=x);
    }
    void rotate(int x)
    {
        int y=tr[x].fa; int z=tr[y].fa;
        int l,r;
        if(tr[y].ch[0]==x) l=0; else l=1; r=l^1;
        if(!isroot(y))
        {
            if(tr[z].ch[0]==y) tr[z].ch[0]=x;
            else tr[z].ch[1]=x;
        }
        tr[y].ch[l]=tr[x].ch[r]; tr[tr[x].ch[r]].fa=y;
        tr[x].ch[r]=y;  tr[y].fa=x;   tr[x].fa=z;
        update(y); update(x);   
    }
    void splay(int x)
    {
        push(x);
        while(!isroot(x))
        {
            int y=tr[x].fa; int z=tr[y].fa;
            if(!isroot(y))
            {
                if((tr[z].ch[0]==y)^(tr[y].ch[0]==x)) rotate(y);
                else rotate(x); 
            }
            rotate(x);  
        }
    }
    void access(int x)
    {
        int y=0;
        for(;x;y=x,x=tr[x].fa)
        {
            splay(x);
            tr[x].ch[1]=y;
            update(x);  
        }           
    }   
    int findroot(int x)
    {
        access(x); splay(x);
        while(tr[x].ch[0]!=0) x=tr[x].ch[0];
        return x;
    }
    void rever(int x)
    {
        access(x);splay(x); tr[x].rev^=1;       
    }
    void link(int x,int y)
    {
        rever(x); tr[x].fa=y;
    }
    void cut(int x,int y)
    {
        if(findroot(x)!=findroot(y)) return;
        rever(x); access(y); splay(y);
        tr[x].fa=tr[y].ch[0]=0;
        update(y);
    }
    int query(int x,int y)
    {
        rever(x); access(y); splay(y);
        return tr[y].pos;
    }
}LCT;
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    memset(val,0,sizeof(val));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&e[i].u,&e[i].v,&e[i].a,&e[i].b);
    }
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        val[n+i]=e[i].b;
    }
    for(int i=0;i<=n+m;i++)
    {
        LCT.init(i);
    }
    ans=inf;
    for(int i=1;i<=m;i++)
    {
        int fx=LCT.findroot(e[i].u); int fy=LCT.findroot(e[i].v);
        if(fx!=fy) 
        {

            LCT.link(e[i].u,i+n);
            LCT.link(i+n,e[i].v);
        }
        else
        {
            int k=LCT.query(e[i].u,e[i].v);         
            if(val[k]>e[i].b)                       
            {                                       
                LCT.cut(e[i].u,k);                  
                LCT.cut(e[i].v,k);
                LCT.link(e[i].u,i+n);
                LCT.link(e[i].v,i+n);       
            }   
        }
        if(LCT.findroot(1)==LCT.findroot(n))    ans=min(ans,val[LCT.query(1,n)]+e[i].a);
    }
    if(ans!=inf)
    printf("%d",ans);
    else printf("-1");
    return 0;
}