Tourists Codeforces

https://codeforces.com/contest/487/problem/E

http://uoj.ac/problem/30

显然割点走过去就走不回来了...可以看出题目跟点双有关

有一个结论：如果在点双中有不同的点a,b,c，那么一定存在点不重复的路径从a到c再到b。

证明（摘自https://codeforces.com/blog/entry/14832）：

显然这样的点双中，点数>=3，因此移除任意点或任意边，仍然连通

新建一张网络流图。用边(u,v,w)表示从u到v容量为w的边

对于原点双中每一条边(u,v)，建新边(u,v,1),(v,u,1)

新建点S,T，建边(S,c,2),(a,T,1),(b,T,1)

用拆点的方法，给S,T,c外的每一个点1的容量（拆点过程略）

此时，显然如果S到T的最大流为2，那么存在合法方案

最大流=最小割。显然最小割<=2（割掉(a,T)与(b,T)的边）。割掉新图中任意一条权值为1的边（除(a,T),(b,T)），对应删除原点双的一条边或一个点，显然删除之后原图仍然连通，则新图也连通。因此最小割>1。所以最小割=2

就是说，如果走的时候要穿过一个点双（任意点开始，任意点结束），那么一定可以找到一条合法路径经过点双内权值最小的点

有一个想法：

可以点双缩点成树（圆方树）（每个点双新建一个点，向点双中所有点连边，删除原图中所有边）

（树中代表一个点双的点的权值是点双中点权的最小值）

然后查询就是树上两点路径上最小值，修改就是单点修改（每个点双用一个multiset维护点双中所有点的权值。修改非割点就直接在它属于的点双的multiset中改，如果multiset中最小值变了就对应修改维护最小值的数据结构；修改割点方法在后面），用树剖维护即可

好像还不怎么对。。割点也是属于点双的，但是修改割点权值显然不能暴力修改其属于的所有点双

看了题解，方法是：每个割点就当做属于它在缩点树中的父亲（这个父亲一定代表一个点双；如果不存在父亲就不用维护），每次修改就在这个父亲的multiset那里改；同时每次查询的时候，如果两点的lca代表一个点双，那么除两点路径上最小值外还要考虑lca的父亲（一定是个割点；如果不存在父亲就不用额外查）

然而真的码不动。。5K代码，续了一下午A掉

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<set>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
struct E
{
    int to,nxt;
};
int a[200010];
int n,m,qq;
namespace S
{
#define lc (num<<1)
#define rc (num<<1|1)
int d[800100];
void setx(int L,int x,int l,int r,int num)
{
    if(l==r)    {d[num]=x;return;}
    int mid=l+((r-l)>>1);
    if(L<=mid)    setx(L,x,l,mid,lc);
    else    setx(L,x,mid+1,r,rc);
    d[num]=min(d[lc],d[rc]);
}
int gmin(int L,int R,int l,int r,int num)
{
    if(L<=l&&r<=R)    return d[num];
    int mid=l+((r-l)>>1);int ans=0x3f3f3f3f;
    if(L<=mid)    ans=min(ans,gmin(L,R,l,mid,lc));
    if(mid<R)    ans=min(ans,gmin(L,R,mid+1,r,rc));
    return ans;
}
int getmin(int L,int R,int l,int r,int num)
{
    if(L>R)    swap(L,R);
    //printf("19t%d %d %d
",L,R,gmin(L,R,l,r,num));
    return gmin(L,R,l,r,num);
}
}
int cnt;
int bno[100010];
bool iscut[100010];
namespace T
{
E e[400100];
int f1[200100],ne;
void me(int x,int y)
{
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;
    e[++ne].to=x;e[ne].nxt=f1[y];f1[y]=ne;
}
bool vis[200100];
int sz[200100],hson[200100],tp[200100],dep[200100];
void dfs1(int u,int fa)
{
    sz[u]=1;
    vis[u]=1;
    for(int k=f1[u];k;k=e[k].nxt)
        if(e[k].to!=fa)
        {
            dep[e[k].to]=dep[u]+1;
            dfs1(e[k].to,u);
            sz[u]+=sz[e[k].to];
            if(sz[e[k].to]>sz[hson[u]])
                hson[u]=e[k].to;
        }
}
int ar[200100],lp[200100],f[200100];
void dfs2(int u,int fa)
{
    ar[++ar[0]]=u;lp[u]=ar[0];
    f[u]=fa;
    if(u==hson[fa])    tp[u]=tp[fa];
    else    tp[u]=u;
    if(hson[u])    dfs2(hson[u],u);
    for(int k=f1[u];k;k=e[k].nxt)
        if(e[k].to!=fa&&e[k].to!=hson[u])
            dfs2(e[k].to,u);
}
multiset<int> s[100100];//s[i]维护i号点双里面所有非割点的权值
void update2(int x)
{
    a[x+n]=*s[x].begin();
    //printf("9t%d %d
",x,a[x+n]);
    S::setx(lp[x+n],a[x+n],1,n+cnt,1);
}
void change(int x,int y)
{
    if(!iscut[x])
    {
        s[bno[x]].erase(s[bno[x]].find(a[x]));
        s[bno[x]].insert(a[x]=y);
        update2(bno[x]);
    }
    else
    {
        if(f[x])
        {
            s[f[x]-n].erase(s[f[x]-n].find(a[x]));
            s[f[x]-n].insert(y);
            update2(f[x]-n);
        }
        a[x]=y;
        S::setx(lp[x],y,1,n+cnt,1);
    }
}
int query(int x,int y)
{
    if(x==y)    return a[x];
    //printf("99t%d %d
",x,y);
    //if(!iscut[x])    x=n+bno[x];
    //if(!iscut[y])    y=n+bno[y];
    int ans=0x3f3f3f3f;
    while(tp[x]!=tp[y])
    {
        if(dep[tp[x]]<dep[tp[y]])    swap(x,y);
        //printf("7t%d %d
",x,y);
        ans=min(ans,S::getmin(lp[x],lp[tp[x]],1,n+cnt,1));
        x=f[tp[x]];
    }
    ans=min(ans,S::getmin(lp[x],lp[y],1,n+cnt,1));
    if(dep[x]>dep[y])    swap(x,y);
    if(x>n&&f[x])    ans=min(ans,a[f[x]]);
    return ans;
}
void work()
{
    int i;
    /*
    for(i=1;i<=n+cnt;i++)
        for(int k=f1[i];k;k=e[k].nxt)
            printf("1t%d %d
",i,e[k].to);
    for(i=1;i<=n;i++)
        printf("%d ",bno[i]);
    puts("t2");
    for(i=1;i<=n;i++)
        printf("%d ",int(iscut[i]));
    puts("t3");
    */
    for(i=1;i<=n+cnt;i++)
        if(!vis[i])
        {
            dfs1(i,0);
            dfs2(i,0);
        }
    /*
    for(i=1;i<=ar[0];i++)
        printf("%d ",ar[i]);
    puts("t4");
    for(i=1;i<=n+cnt;i++)
        printf("%d ",lp[i]);
    puts("t5");
    for(i=1;i<=n+cnt;i++)
        printf("6t%d %d
",f[i],tp[i]);
    */
    for(i=1;i<=n;i++)
        if(!iscut[i])
        {
            s[bno[i]].insert(a[i]);
            S::setx(lp[i],0x3f3f3f3f,1,n+cnt,1);
        }
        else
        {
            if(f[i])
            {
                s[f[i]-n].insert(a[i]);
            }
            S::setx(lp[i],a[i],1,n+cnt,1);
        }
    for(i=1;i<=cnt;i++)
        update2(i);
    //for(i=1;i<=ar[0];i++)
    //    printf("16t%d
",S::getmin(i,i,1,n+cnt,1));
}

}
namespace G
{
E e[200100];
int f1[100010],ne=1;
void me(int x,int y)
{
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;
    e[++ne].to=x;e[ne].nxt=f1[y];f1[y]=ne;
}
int dfc,dfn[100010];
pii st[100010];int tp;
int dfs(int u,int last)
{
    //printf("3t%d %d
",u,last);
    int k,v,lowu=dfn[u]=++dfc,chi=0,lowv;pii x;
    for(k=f1[u];k;k=e[k].nxt)
    {
        v=e[k].to;
        if(!dfn[v])
        {
            st[++tp]=mp(u,v);++chi;
            lowv=dfs(v,k);lowu=min(lowu,lowv);
            if(lowv>=dfn[u])
            {
                //printf("4t%d %d
",u,v);
                iscut[u]=1;
                ++cnt;
                for(;;)
                {
                    x=st[tp--];
                    if(bno[x.fi]!=cnt)
                    {
                        bno[x.fi]=cnt;
                        T::me(n+cnt,x.fi);
                    }
                    if(bno[x.se]!=cnt)
                    {
                        bno[x.se]=cnt;
                        T::me(n+cnt,x.se);
                    }
                    if(x.fi==u&&x.se==v)    break;
                }
            }
        }
        else if(dfn[v]<dfn[u]&&k!=(last^1))
        {
            st[++tp]=mp(u,v);
            lowu=min(lowu,dfn[v]);
        }
    }
    if(!last&&chi==1)    iscut[u]=0;
    //printf("5t%d %d %d
",u,lowu,dfn[u]);
    return lowu;
}
}


int main()
{
    char tmp[233];
    int i,x,y;
    scanf("%d%d%d",&n,&m,&qq);
    for(i=1;i<=n;i++)    scanf("%d",&a[i]);
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        G::me(x,y);
    }
    for(i=1;i<=n;i++)
        if(!G::dfn[i])
            G::dfs(i,0);
    T::work();
    while(qq--)
    {
        scanf("%s%d%d",tmp,&x,&y);
        if(tmp[0]=='C')
        {
            T::change(x,y);
        }
        else
        {
            printf("%d
",T::query(x,y));
        }
    }
    return 0;
}