Tourists Codeforces - 487E

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[];
 int n,m,qq;
 namespace S
 {
 #define lc (num<<1)
 #define rc (num<<1|1)
 int d[];
 void setx(int L,int x,int l,int r,int num)
 {
     if(l==r)    {d[num]=x;return;}
     int mid=l+((r-l)>>);
     if(L<=mid)    setx(L,x,l,mid,lc);
     else    setx(L,x,mid+,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)>>);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+,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\n",L,R,gmin(L,R,l,r,num));
     return gmin(L,R,l,r,num);
 }
 }
 int cnt;
 int bno[];
 bool iscut[];
 namespace T
 {
 E e[];
 int f1[],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[];
 int sz[],hson[],tp[],dep[];
 void dfs1(int u,int fa)
 {
     sz[u]=;
     vis[u]=;
     for(int k=f1[u];k;k=e[k].nxt)
         if(e[k].to!=fa)
         {
             dep[e[k].to]=dep[u]+;
             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[],lp[],f[];
 void dfs2(int u,int fa)
 {
     ar[++ar[]]=u;lp[u]=ar[];
     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[];//s[i]维护i号点双里面所有非割点的权值
 void update2(int x)
 {
     a[x+n]=*s[x].begin();
     //printf("9t%d %d\n",x,a[x+n]);
     S::setx(lp[x+n],a[x+n],,n+cnt,);
 }
 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,,n+cnt,);
     }
 }
 int query(int x,int y)
 {
     if(x==y)    return a[x];
     //printf("99t%d %d\n",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\n",x,y);
         ans=min(ans,S::getmin(lp[x],lp[tp[x]],,n+cnt,));
         x=f[tp[x]];
     }
     ans=min(ans,S::getmin(lp[x],lp[y],,n+cnt,));
     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\n",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=;i<=n+cnt;i++)
         if(!vis[i])
         {
             dfs1(i,);
             dfs2(i,);
         }
     /*
     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\n",f[i],tp[i]);
     */
     for(i=;i<=n;i++)
         if(!iscut[i])
         {
             s[bno[i]].insert(a[i]);
             S::setx(lp[i],0x3f3f3f3f,,n+cnt,);
         }
         else
         {
             if(f[i])
             {
                 s[f[i]-n].insert(a[i]);
             }
             S::setx(lp[i],a[i],,n+cnt,);
         }
     for(i=;i<=cnt;i++)
         update2(i);
     //for(i=1;i<=ar[0];i++)
     //    printf("16t%d\n",S::getmin(i,i,1,n+cnt,1));
 }

 }
 namespace G
 {
 E e[];
 int f1[],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;
 }
 int dfc,dfn[];
 pii st[];int tp;
 int dfs(int u,int last)
 {
     //printf("3t%d %d\n",u,last);
     int k,v,lowu=dfn[u]=++dfc,chi=,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\n",u,v);
                 iscut[u]=;
                 ++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^))
         {
             st[++tp]=mp(u,v);
             lowu=min(lowu,dfn[v]);
         }
     }
     if(!last&&chi==)    iscut[u]=;
     //printf("5t%d %d %d\n",u,lowu,dfn[u]);
     return lowu;
 }
 }

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