CF487E Tourists + 圆方树学习笔记（圆方树+树剖+线段树+multiset)

QWQ果然我已经什么都学不会的人了。

这个题目要求的是图上所有路径的点权和！QWQ（我只会树上啊！）

这个如果是好啊

这时候就需要

圆方树！

首先在介绍圆方树之前，我们先来一点简单的前置知识

首先，我们需要知道什么是

点双联通分量

若一个无向图中的去掉任意一个节点都不会改变此图的连通性，即不存在割点，则称作点双连通图。那么一个极大的点双联通子图，就是一个双联通分量了

那么求这个方法，和普通求割点的\(tarjan\)类似

用一个栈维护所有的点

对于搜索到一个割点，然后把他的栈内部的点依次弹栈，直到这条边的\(to\)被弹出来为止（这里不能直接把当前弹出去的原因是一个点可能属于好几个点双联通，所以如果此时把这个点弹出去，是错误的

代码就直接搬了圆方树里面的，请手动忽略\(addedge\)

void tarjan(int x,int faa)
{
    dfn[x]=low[x]=++tot;
    st[++ttop]=x;
    for (int i=point1[x];i;i=nxt1[i])
    {
        int p = to1[i];
        if (p==faa) continue;
        if (!dfn[p])
        {
            tarjan(p,x);
            low[x]=min(low[x],low[p]);
            if (low[p]>=dfn[x]) //如果这个点是割点，就把当前点双的所有点出栈，建成圆方树
            {
                ++num;
                addedge(num,x);
                addedge(x,num);
                do
                {
                   addedge(st[ttop],num);
                   addedge(num,st[ttop]);
                   ttop--;
                 }while (st[ttop+1]!=p);
            }
        }
        else
          low[x]=min(low[x],dfn[p]);
    }
}

QWQ那么圆方树是怎么一个东西呢。

实际上圆方树就是把图中所有的点双连通分量找出来，然后建一个新的方点

和所有的点双里面的点连边，然后把原图对应点双里面的边都删除（相当于建了一个新图）

然后新建的点是方点，原图的点是原点

这里直接引用了猫琨的图qwq

那么经过这么一番处理，我们会发现（详细证明请看WC的ppt）

这个由圆点和方点组成的新图是一颗树

叫做

圆方树

那么圆方树有什么性质呢？

性质

1任意两个圆点（或方点）不会相邻。

2.如果两个方点树上距离是那么一定有一个圆点连接他们，而且这个圆点是两个方点对应点双的公共点。

3，对于两个圆点 \(a,b\)之间的树上路径，

(1)路径上的所有圆点都是割点！

(2)\(a,b\)所有简单路径的并 是路径上所有方点对应的点双（包括\(a=b\)的情况）

QWQ然后我们就能够将大部分图上问题直接转化成树上问题了

那么对于这个题。

首先，询问路径的上的简单路径的点权\(min\)，我们可以将方点的权值设为所连圆点的权值\(min\)（这里要开一个\(set）\)，然后圆点的点权弄成原来的权值，对于每次询问，我们直接回答链\(min\)就行，这个可以用线段树+树剖来实现。

那么修改呢

QWQ

由于我们考虑到，一个圆点的点权修改，最多会影响到\(O(n)\)个级别的方点（一个点可以属于好几个点双）。

QWQ

那么该如何是好呢？

我们考虑对于每个方点，维护除去他的根（建出来树先dfs一下）的所有圆点的权值的\(min\)（由于涉及到删除什么的，所以要用\(multiset\)）

那么这样每次修改，我们只需要修改对应圆点的\(fa\)的\(set\)就ok了

有一个要注意的地方就是！

如果我们对于一次询问的\(lca\)，假设他的方点的话，我们还要考虑他的\(fa\)的\(val\)大小，因为我们只询问路径上的方点，不会计算这个点的。

总的来说，一般圆方树的题都要很好的运用圆方树的性质的

（虽然我根本想不到圆方树）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define mk makr_pair
#define ll long long
using namespace std;
inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}
const int maxn = 2e5+5;
const int maxm = 2*maxn;
int point[maxn],nxt[maxm],to[maxm];
int point1[maxn],nxt1[maxm],to1[maxm];
int cnt1,cnt;
int n,m,k,q;
int deep[maxn];
int top[maxn],size[maxn],son[maxn];
int fa[maxn];
int f[4*maxn];
int add[4*maxn];
multiset<int> s[maxn];
int val[maxn];
int tot;
int low[maxn],dfn[maxn];
int newnum[maxn],newval[maxn];
int st[maxn],ttop;
int num,tmp;
void addedge(int x,int y)
{
// cout<<x<<" "<<y<<"  *"<<endl;
    nxt[++cnt]=point[x];
    to[cnt]=y;
    point[x]=cnt;
}
void addedge1(int x,int y)
{
    nxt1[++cnt1]=point1[x];
    to1[cnt1]=y;
    point1[x]=cnt1;
}
void tarjan(int x,int faa)
{
    dfn[x]=low[x]=++tot;
    st[++ttop]=x;
    for (int i=point1[x];i;i=nxt1[i])
    {
        int p = to1[i];
        if (p==faa) continue;
        if (!dfn[p])
        {
            tarjan(p,x);
            low[x]=min(low[x],low[p]);
            if (low[p]>=dfn[x]) //如果这个点是割点，就把当前点双的所有点出栈，建成圆方树
            {
                ++num;
                addedge(num,x);
                addedge(x,num);
                do
                {
                   addedge(st[ttop],num);
                   addedge(num,st[ttop]);
                   ttop--;
                 }while (st[ttop+1]!=p);
            }
        }
        else
          low[x]=min(low[x],dfn[p]);
    }
}
void dfs1(int x,int faa,int dep)
{
    deep[x]=dep;
    size[x]=1;
    int maxson=-1;
    for (int i=point[x];i;i=nxt[i])
    {
        int p =to[i];
        if (p==faa) continue;
        fa[p]=x;
        dfs1(p,x,dep+1);
        if (size[p]>maxson)
        {
            maxson=size[p];
            son[x]=p;
        }
        size[x]+=size[p];
    }
}
void dfs2(int x,int chain)
{
    newnum[x]=++tmp;
    newval[tmp]=val[x];
    top[x]=chain;
    if (!son[x]) return;
    dfs2(son[x],chain);
    for (int i=point[x];i;i=nxt[i])
    {
        int p = to[i];
        if (!newnum[p])
        {
            dfs2(p,p);
        }
    }
}
void up(int root)
{
    f[root]=min(f[2*root],f[2*root+1]);
}
void build(int root,int l,int r)
{
    if (l==r)
    {
         f[root]=newval[l];
         return;
    }
    int mid =l + r >> 1;
    build(2*root,l,mid);
    build(2*root+1,mid+1,r);
    up(root);
}
void update(int root,int l,int r,int x,int p)
{
    if (l==r)
    {
        f[root]=p;
        return;
    }
    int mid = l+r >> 1;
    if (x<=mid) update(2*root,l,mid,x,p);
    if (x>mid) update(2*root+1,mid+1,r,x,p);
    up(root);
}
int query(int root,int l,int r,int x,int y)
{
    if (x<=l && r<=y) return f[root];
    int mid = l+r >> 1;
    int ans=2e9;
    if (x<=mid) ans=min(ans,query(2*root,l,mid,x,y));
    if (y>mid) ans=min(ans,query(2*root+1,mid+1,r,x,y));
    return ans;
}
int treesum(int x,int y)
{
    int ans=2e9;
    int xx=x,yy=y;
    while (top[x]!=top[y])
    {
        if (deep[top[x]]<deep[top[y]]) swap(x,y);
        //cout<<1<<endl;
        ans=min(ans,query(1,1,num,newnum[top[x]],newnum[x]));
        x=fa[top[x]];
        //cout<<"***"<<endl;
    }
// cout<<1<<endl;
    //cout<<x<<" "<<y<<endl;
    if (deep[x]>deep[y]) swap(x,y);
    ans=min(ans,query(1,1,num,newnum[x],newnum[y]));
    int l = x;
    if (l>n) ans=min(ans,val[fa[l]]);
    return ans;
}
int main()
{
  n=read(),m=read(),q=read();
  tmp=0;
  num=n;
  for (int i=1;i<=n;i++) val[i]=read();
  for (int i=1;i<=m;i++)
  {
   int x=read(),y=read();
   addedge1(x,y);
    addedge1(y,x);
  }
  for (int i=1;i<=n;i++)
  {
     if(!dfn[i]) tarjan(i,0);
   }
  dfs1(1,0,1);
  for (int i=n+1;i<=num;i++)
  {
     for (int j=point[i];j;j=nxt[j])
     {
      int p = to[j];
      if (p==fa[i]) continue;
      s[i].insert(val[p]);
      }
      if (s[i].size()==0) val[i]=2e9;
      else val[i]=*(s[i].begin());
  }
  dfs2(1,1);
  build(1,1,num);
  for (int i=1;i<=q;i++)
  {
    char ss[10];
    scanf("%s",ss+1);
    if (ss[1]=='C')
     {
     int x=read(),y=read();
     update(1,1,num,newnum[x],y);
     if (fa[x]==0)
     {
      val[x]=y;
      continue;
           }
     int now = *(s[fa[x]].begin());
        s[fa[x]].erase(s[fa[x]].find(val[x]));
        s[fa[x]].insert(y);
        int tmp1 = (*(s[fa[x]].begin()));
        if (tmp1!=now)
        {
            update(1,1,num,newnum[fa[x]],tmp1);
            val[fa[x]]=tmp1;
        }
        val[x]=y;
     }
     else
     {
      int x=read(),y=read();
      cout<<treesum(x,y)<<"\n";
     }
  }
  return 0;
}