cf 487E Tourist

最新推荐文章于 2025-09-04 17:59:41 发布

转载最新推荐文章于 2025-09-04 17:59:41 发布 · 71 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/acha/p/7185741.html

本文介绍了一种解决特定图论问题的方法，即通过将无向连通图转换为点双连通分量构成的树来求解单点修改与路径最小值查询的问题。文章详细阐述了实现过程，并提供了完整的代码示例。

题目大意

给定\(n\)个点\(m\)条边的无向连通图，无重边
每个点有点权
两个操作：
1.单点点权修改
2.询问从x到y的简单路径中，路径经过点的最小值的最小值时多少
（简单路径指经过每一个点至多一次）

分析

使用点双连通分量转化为树
（点双连通分量表示该连通分量中，去掉任意一个点都不回使其不连通）
这样子
当我们经过一个点双连通分量的至少两个点时，可以拿到这个点双内的最小权值
证明：
1.当只经过一个点时，经过的是一个割点，只经过一个点的情况下，不能进入该点双
2.当经过至少两个点时
①该点双只有两个点，显然成立
②该点双有\(\ge 3\)个点时，设最开始经过a，最后经过的点是b，该点双的最小值为c
当c为a或者b时，成立
否则，一定存在一条从a-c-b的路径
证明：
因为是点双，所以a-c,a-b,c-b的路径一定都是存在的
假设不存在从a-c-b的路径
说明任选一个a-c路径，所有b-c路径都与它有交
若交点有两个，则可以从a出发，走最近的交点到c，然后走另一个交点去b
否则只有一个交点，该点为b-c的必经点，删除后导致点双不连通，与定义矛盾

做法

类似圆方树的方法
点双中间加个特殊点
这篇博客挺好的
修改时不能全改（儿子多）
那就只改父亲
特判lca为特殊的情况，此时经过了该点双至少两个点
而点双中特殊点的父亲那个点并没有统计到

solution

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <functional>
#include <algorithm>
#include <queue>
using namespace std;
const int M=2e5+7;
const int INF=1e9+7;

inline int ri(){
    int x=0;bool f=1;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=0;
    for(;isdigit(c);c=getchar()) x=x*10+c-48;
    return f?x:-x;
}

int n,m,q;
int val[M];

struct vec{
    int g[M],te;
    struct edge{
        int y,nxt;
        edge(int _y=0,int _nxt=0){y=_y,nxt=_nxt;}
    }e[M<<1];
    vec(){memset(g,0,sizeof g);te=0;}
    inline void push(int x,int y){e[++te]=edge(y,g[x]);g[x]=te;}
    inline void push2(int x,int y){push(x,y);push(y,x);}
    inline int& operator () (int x){return g[x];}
    inline edge& operator [] (int x){return e[x];}
}e;

struct Heap{
    priority_queue<int,vector<int>,greater<int> >q,ers;
    inline void ins(int d){q.push(d);}
    inline void del(int d){ers.push(d);}
    int top(){
        while(!ers.empty()&&q.top()==ers.top()) q.pop(),ers.pop();
        return q.top();
    }
};

namespace Seg{
    int a[524299];
    int n;
    
    inline void pushup(int x){a[x]=min(a[x<<1],a[x<<1|1]);}

    void ins(int x,int l,int r,int to,int d){
        if(l==r){
            a[x]=d;
            return;
        }
        int mid=l+r>>1;
        if(to<=mid) ins(x<<1,l,mid,to,d);
        else ins(x<<1|1,mid+1,r,to,d);
        pushup(x);
    }

    int get(int x,int l,int r,int tl,int tr){
        if(tl<=l&&r<=tr) return a[x];
        int mid=l+r>>1;
        if(tr<=mid) return get(x<<1,l,mid,tl,tr);
        if(mid<tl) return get(x<<1|1,mid+1,r,tl,tr);
        return min(get(x<<1,l,mid,tl,tr),get(x<<1|1,mid+1,r,tl,tr));
    }

    void ins(int x,int d){ins(1,1,n,x,d);}
    int get(int x,int y){return get(1,1,n,x,y);}
    int get(int x){return get(1,1,n,x,x);}
}

namespace Tr{
    vec e;
    Heap h[M];

    int pre[M],dep[M];
    int sz[M],son[M];
    int top[M],tdfn;
    int tid[M],pid[M];

    void dfs1(int x){
        int p,y;
        sz[x]=1; son[x]=0;
        for(p=e(x);p;p=e[p].nxt)
        if((y=e[p].y)!=pre[x]){
            dep[y]=dep[x]+1;
            pre[y]=x;
            dfs1(y);
            sz[x]+=sz[y];
            if(sz[y]>sz[son[x]]) son[x]=y;
        }
    }

    void dfs2(int x){
        int p,y;
        pid[tid[x]=++tdfn]=x;
        if(y=son[x]){
            top[y]=top[x];
            dfs2(y);
        }
        for(p=e(x);p;p=e[p].nxt)
        if((y=e[p].y)!=pre[x]&&y!=son[x]){
            top[y]=y;
            dfs2(y);
        }
    }

    void split(){
        pre[1]=0;dep[1]=1;
        dfs1(1);
        top[1]=1;tdfn=0;
        dfs2(1);
    }

    int LCA(int x,int y){
        while(top[x]!=top[y]){
            if(dep[top[x]]<dep[top[y]]) swap(x,y);
            x=pre[top[x]];
        }
        return dep[x]<dep[y]?x:y;
    }

    void mdf(int x,int pr,int nw){
        Seg::ins(tid[x],nw);
        if(pre[x]==0) return;
        if(pr>0) h[pre[x]].del(pr);
        h[pre[x]].ins(nw);
        Seg::ins(tid[pre[x]],h[pre[x]].top());
    }
    
    int get(int x,int y){
        int lca=LCA(x,y),res=INF;
        for(;dep[top[x]]>dep[lca];x=pre[top[x]])
            res=min(res,Seg::get(tid[top[x]],tid[x]));
        if(dep[x]>dep[lca])
            res=min(res,Seg::get(tid[lca]+1,tid[x]));
        for(;dep[top[y]]>=dep[lca];y=pre[top[y]])
            res=min(res,Seg::get(tid[top[y]],tid[y]));
        if(dep[y]>=dep[lca])
            res=min(res,Seg::get(tid[lca],tid[y]));
        if(lca>n&&pre[lca]) res=min(res,Seg::get(tid[pre[lca]]));
        return res;
    }

    void push(int x,int y){e.push2(x,y);}
}

namespace G{
    vec e;

    int dfn[M],low[M],tdfn;
    int stack[M],Top;
    int cnt;

    void BCC(int x,int fr){
        int p,y;
        dfn[x]=low[x]=++tdfn;
        stack[++Top]=x;
        for(p=e(x);p;p=e[p].nxt)
        if((y=e[p].y)!=fr){
            if(dfn[y]) low[x]=min(low[x],dfn[y]);
            else{
                BCC(y,x);
                low[x]=min(low[x],low[y]);
                if(low[y]>=dfn[x]){
                    cnt++;
                    Tr::push(x,cnt);
                    do{Tr::push(cnt,stack[Top]);}while(y!=stack[Top--]);
                }
            }
        }
    }

    void push(int x,int y){e.push2(x,y);}
}

int main(){

    int i,x,y; char s[9];
    n=ri(),m=ri(),q=ri();
    for(i=1;i<=n;i++) val[i]=ri();

    for(i=1;i<=m;i++) G::push(ri(),ri());
    
    G::cnt=n;
    G::BCC(1,0);
    Seg::n=G::cnt;

    Tr::split();

    for(i=1;i<=n;i++) Tr::mdf(i,0,val[i]);

    for(i=1;i<=q;i++){
        scanf("%s",s);
        if(s[0]=='C'){
            x=ri(), y=ri();
            Tr::mdf(x,val[x],y);
            val[x]=y;
        }
        else if(s[0]=='A'){
            x=ri(),y=ri();
            printf("%d\n",Tr::get(x,y));
        }
    }

    return 0;
}

转载于:https://www.cnblogs.com/acha/p/7185741.html