「笔记」圆方树

写在前面
简介
定义
构建
性质
例题
写在最后

写在前面

¿immortalCO 是一只猫?（西班牙语并感

简介

圆方树是一种无向图的重构树。通过对原图建立圆方树可以将原图上的某些问题转化到树上，并套用一些树上算法处理。

圆方树最初是用于仙人掌图的一种工具，后经过扩展，使得它可以在一般无向图上应用。本文仅分析它在一般无向图上的应用，圆方树在仙人掌图上圆方树的定义与下文有所不同。有关如何使用圆方树解决仙人掌图问题可以参考：圆方树——处理仙人掌的利器 - immortalCO。

定义

对于一个一般无向图，其圆方树的构造过程可以以下列方式直观理解：

原图中的点被称为圆点。
求得原图中所有点双连通分量，对每一个点双都新建一个节点，这类点被称为方点。
删去原图中所有边，令每一个圆点向包含该点的点双对应的方点连边。

以下是对给定无向图建圆方树的一个图示：

图片来源：WC2018讲课论文圆方树simple_immortalCO^[1]

构建

使用 Tarjan 算法求得所有点双的同时构建圆方树即可，代码如下所示。

int n, m, e_num, head[kN], v[kN << 1], ne[kN << 1]; //原图信息
int dfnnum, cnt, dfn[kN], low[kN]; //Tarjan 相关变量
std::vector <int> newv[kN]; //圆方树中的边

void Tarjan(int u_) {
  dfn[u_] = low[u_] = ++ dfnnum;
  st.push(u_);

  for (int i = head[u_]; i; i = ne[i]) {
    int v_ = v[i];
    if (!dfn[v_]) {
      Tarjan(v_);
      Chkmin(low[u_], low[v_]);
      if (low[v_] >= dfn[u_]) { //删去 u_ 后 v_ 与原图其他部分不连通，u_ 是一个割点。
        ++ cnt;
        newv[cnt].push_back(u_), newv[u_].push_back(cnt); //新建方点
        while (true) {
          int top_ = st.top();
          newv[cnt].push_back(top_), newv[top_].push_back(cnt);
          st.pop();
          if (top_ == v_) break; //特 别 注 意终止条件
        }
      }
    } else {
      Chkmin(low[u_], dfn[v_]);
    }
  }
}
int main() {
  Init();
  for (int i = 1; i <= n; ++ i) { //注意原图可能不连通
    if (!dfn[i]) Tarjan(i);
  }
}

性质

树上圆点仅会和方点相连，方点仅会和圆点相连。
圆方树的节点个数为 \(O(n)\) 级别。
如果原图连通，那么它的圆方树是一棵树。若原图中有 \(k\) 个连通分量，原图的圆方树是由 \(k\) 棵树形成的森林。

性质 1 的正确性显然，代码中连边操作仅会发生在圆点与方点之间。

性质 2 也显然，原图中点双连通分量至多有 \(n\) 个，则新建方点的个数是 \(O(n)\) 级别的。关于为什么点双至多有 \(n\) 个，可以发现代码中每新找到点双并连边时，一定会伴随着至少一次出栈操作。又每个节点至多入栈一次，至多发生 \(n\) 次出栈操作，得证。

对于性质 3，考虑反证法，设存在一种一般无向图的圆方树中存在环。考虑到性质 1，圆方树中的环一定是圆点方点交替连接形式。考虑到环中的一个圆点，它与不少于两个方点之间都有边，说明它同时存在于多个点双中。
引理：不是割点的点至多存在于一个点双中。正确性可通过阅读代码得到证明，若一个节点不是割点，在构建圆方树时，它与对应方点的连边仅会发生在循环弹栈中，又至多入栈并出栈一次，得证。
根据引理，环中的圆点一定都是割点，删除割点会使得原图不连通，这与环的性质相冲突。反证性质 3 成立。

例题

「BJOI2013」压力

圆方树，树上差分

给定一 \(n\) 个节点 \(m\) 条边的无向图，有 \(q\) 组点对。求每个节点能作为多少组点对路径上的必经点。
\(1\le n\le 10^5\)，\(1\le m,q\le 2\times 10^5\)。
128MB，10S。

点双存在一个性质：对于点数 \(\ge 3\) 的点双中任意两个不同的点之间，一定存在一条简单路径经过在同一点双内的任意一点。正确性可以通过点双的定义感性理解，一种严谨的证明详见 OI-Wiki 某题题解。
则对于一给定点对，若它们之间存在一条路径经过某点双上两点，则该点双上所有点都不是必经点。更进一步地，它们之间的必经点是起点终点路径上点双的交集，即路径上的割点。

考虑建立圆方树，两点原图路径上的割点，即为圆方树路径上的圆点。问题转化为每个圆点被多少路径覆盖，树上差分即可。总复杂度 \(O(n+q\log n)\) 级别。

//知识点：圆方树
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
#define LL long long
const int kN = 2e5 + 10;
//=============================================================
int n, m, q, e_num, head[kN], v[kN << 1], ne[kN << 1];
int dfnnum, cnt, dfn[kN], low[kN];
int ans[kN];
std::vector <int> newv[kN];
std::stack <int> st;
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmax(int &fir, int sec) {
  if (sec > fir) fir = sec;
}
void Chkmin(int &fir, int sec) {
  if (sec < fir) fir = sec;
}
void Add(int u_, int v_) {
  v[++ e_num] = v_, ne[e_num] = head[u_], head[u_] = e_num;
}
void Tarjan(int u_) {
  dfn[u_] = low[u_] = ++ dfnnum;
  st.push(u_);

  for (int i = head[u_]; i; i = ne[i]) {
    int v_ = v[i];
    if (!dfn[v_]) {
      Tarjan(v_);
      Chkmin(low[u_], low[v_]);
      if (low[v_] >= dfn[u_]) {
        ++ cnt;
        newv[cnt].push_back(u_), newv[u_].push_back(cnt);
        while (true) {
          int top_ = st.top();
          newv[cnt].push_back(top_), newv[top_].push_back(cnt);
          st.pop();
          if (top_ == v_) break;
        }
      }
    } else {
      Chkmin(low[u_], dfn[v_]);
    }
  }
}
namespace HLD {
  int fa[kN], son[kN], dep[kN], sz[kN], top[kN];
  void Dfs1(int u_, int fa_) {
    fa[u_] = fa_;
    sz[u_] = 1;
    dep[u_] = dep[fa_] + 1;
    for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
      int v_ = newv[u_][i];
      if (v_ == fa_) continue ;
      Dfs1(v_, u_);
      if (sz[v_] > sz[son[u_]]) son[u_] = v_;
      sz[u_] += sz[v_];
    }
  }
  void Dfs2(int u_, int top_) {
    top[u_] = top_;
    if (son[u_]) Dfs2(son[u_], top_);
    for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
      int v_ = newv[u_][i];
      if (v_ == fa[u_] || v_ == son[u_]) continue ;
      Dfs2(v_, v_);
    }
  }
  int Lca(int u_, int v_) {
    for (; top[u_] != top[v_]; u_ = fa[top[u_]]) {
      if (dep[top[u_]] < dep[top[v_]]) {
        std::swap(u_, v_);
      }
    }
    return dep[u_] < dep[v_] ? u_ : v_;
  }
}
int Dfs(int u_, int fa_) {
  for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
    int v_ = newv[u_][i];
    if (v_ == fa_) continue ;
    Dfs(v_, u_);
    ans[u_] += ans[v_];
  }
}
//=============================================================
int main() { 
  cnt = n = read(), m = read(), q = read();
  for (int i = 1; i <= m; ++ i) {
    int u_ = read(), v_ = read();
    Add(u_, v_), Add(v_, u_);
  }
  for (int i = 1; i <= n; ++ i) {
    if (!dfn[i]) {
      Tarjan(i);
    }
  }
  HLD::Dfs1(1, 0), HLD::Dfs2(1, 1);
  for (int i = 1; i <= q; ++ i) {
    int u_ = read(), v_ = read(), lca = HLD::Lca(u_, v_);
    ++ ans[u_];
    ++ ans[v_];
    -- ans[lca];
    if (HLD::fa[lca]) -- ans[HLD::fa[lca]];
  }
  Dfs(1, 0);
  for (int i = 1; i <= n; ++ i) printf("%d\n", ans[i]);
  return 0; 
}

「APIO2018」铁人两项

圆方树，树形 DP。

给定一 \(n\) 个节点 \(m\) 条边的无向图，求存在多少对有序三元组 \((s,c,f)\)，满足 \(s,c,f\) 互不相同且存在一条从 \(s\) 到 \(f\) 的简单路径使得 \(c\) 在路径上出现。
\(1\le n\le 10^5\)，\(1\le m\le 2\times 10^5\)。
1S，1G。

同样使用上题中点双的性质，对于点数 \(\ge 3\) 的点双中任意两个不同的点之间，一定存在一条简单路径经过在同一点双内的任意一点。

于是可以考虑建出原图的圆方树。考虑圆方树上任意两个圆点 \(x,y\) 之间的路径上的点：对于路径上某圆点 \(z\)，显然原图中 \(z\) 一定在 \(x\) 到 \(y\) 的一条简单路径上，三元组 \((x,z,y)\) 对答案有贡献。对于路径上某方点，根据上述性质，方点所对应的点双中的所有节点也一定可以出现在 \(x\) 到 \(y\) 的一条简单路径上。
则对于圆方树上任意两圆点 \(s,f\)，能与它们组成合法有序三元组的 \(c\) 即为圆方树上两点路径上圆点与方点维护的所有圆点并集的大小减 2（不包含 \(s,f\)）。考虑到圆方树上圆点只与方点相连，方点只与圆点相连，路径上的圆点一定被路径上它们相邻的方点维护，考虑给各点赋值来方便统计。

考虑令方点权值变为代表的点双的大小，圆点的权值为 \(-1\)。圆方树上任意两圆点对答案的贡献即为路径上点权之和。问题变为统计树上所有以圆点为端点路径权值之和。转化为每个点被多少路径所包括，简单树形 DP 即可。总时间复杂度 \(O(n)\) 级别。

注意原图可能不连通。

代码中并没有显式的 DP 数组。

//知识点：圆方树
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
#define LL long long
const int kN = 2e5 + 10;
//=============================================================
int n, m, e_num, val[kN], head[kN], v[kN << 1], ne[kN << 1];
int sumsz, dfnnum, cnt, dfn[kN], low[kN];
std::vector <int> newv[kN];
std::stack <int> st;
LL ans;
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmax(int &fir, int sec) {
  if (sec > fir) fir = sec;
}
void Chkmin(int &fir, int sec) {
  if (sec < fir) fir = sec;
}
void Add(int u_, int v_) {
  v[++ e_num] = v_, ne[e_num] = head[u_], head[u_] = e_num;
}
void Tarjan(int u_) {
  dfn[u_] = low[u_] = ++ dfnnum;
  st.push(u_);
  ++ sumsz;

  for (int i = head[u_]; i; i = ne[i]) {
    int v_ = v[i];
    if (!dfn[v_]) {
      Tarjan(v_);
      Chkmin(low[u_], low[v_]);
      if (low[v_] >= dfn[u_]) {
        val[++ cnt] = 1;
        newv[cnt].push_back(u_), newv[u_].push_back(cnt);
        while (true) {
          int top_ = st.top();
          ++ val[cnt];
          newv[cnt].push_back(top_), newv[top_].push_back(cnt);
          st.pop();
          if (top_ == v_) break; //特 别 注 意
          //u_ 与 v_ 在栈中可能不相邻，停止条件必须要写成这样
        }
      }
    } else {
      Chkmin(low[u_], dfn[v_]);
    }
  }
}
int Dfs(int u_, int fa_) {
  int sz = u_ <= n;
  for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
    int v_ = newv[u_][i];
    if (v_ == fa_) continue ;
    int ret = Dfs(v_, u_);
    ans += 2ll * sz * ret * val[u_]; //子树内的点经过 u_ 构成的路径
    sz += ret;
  }
  ans += 2ll * sz * (sumsz - sz) * val[u_]; //子树内的点与子树外的点构成的路径
  return sz;
}
//=============================================================
int main() { 
  cnt = n = read(), m = read();
  for (int i = 1; i <= n; ++ i) val[i] = -1;
  for (int i = 1; i <= m; ++ i) {
    int u_ = read(), v_ = read();
    Add(u_, v_), Add(v_, u_);
  }
  for (int i = 1; i <= n; ++ i) { //注意原图可能不连通
    if (dfn[i]) continue ;
    sumsz = 0;
    Tarjan(i); Dfs(i, 0);
  }
  printf("%lld\n", ans);
  return 0; 
}

CF487E Tourists

圆方树，树链剖分

给定一 \(n\) 个节点 \(m\) 条边的无向图，点有点权，给定 \(q\) 次操作：

修改指定点的权值。

查询给定两点所有路径上的点中的最小点权值。

\(1\le n,m,q\le 10^5\)，\(1\le\) 点权 \(\le 10^9\)。
2S，256MB。

先考虑不带修的情况。建立圆方树，令每个方点的权值为其点双内所有节点点权值的最小值。查询时直接查询两点路径节点权值最小值即可。

再考虑带修的情况，一种显然的想法是对每一个方点都维护一个 multiset，储存其点双内所有节点点权值。修改时修改对应节点点权以及其所在所有方点的 mulitiset，并更新方点点权，树剖维护即可。但可能会出现一个圆点与多个方点相连的情况，复杂度没有保证。

如何保证修改一个圆点的点权，只会影响到常数个方点的点权？令每个方点的权值为其圆方树上的儿子的最小点权值即可。此时若某次查询的 \(\operatorname{lca}\) 为一方点，需要统计该点父亲的圆点的贡献。

总复杂度 \(O((n + q)\log n)\) 级别。

//知识点：圆方树，树链剖分
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <set>
#include <stack>
#include <vector>
#define LL long long
const int kN = 2e5 + 10;
const int kInf = 1e9 + 2077;
//=============================================================
int n, m, q, e_num, head[kN], v[kN << 1], ne[kN << 1]; //原图
int dfnnum, cnt, dfn[kN], low[kN]; //对原图 tarjan 时的 dfs 序
int hld_dfnnum, hld_dfn[kN], s[kN]; //对圆方树剖分时的 dfs 序
int val[kN], fa[kN]; //圆方树的父亲、点权
std::vector <int> newv[kN]; //圆方树
std::stack <int> st;
std::multiset <int> minval[kN]; //圆方树中每个方点子节点的权值集合
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmax(int &fir, int sec) {
  if (sec > fir) fir = sec;
}
void Chkmin(int &fir, int sec) {
  if (sec < fir) fir = sec;
}
void Add(int u_, int v_) {
  v[++ e_num] = v_, ne[e_num] = head[u_], head[u_] = e_num;
}
void Tarjan(int u_) {
  dfn[u_] = low[u_] = ++ dfnnum;
  st.push(u_);

  for (int i = head[u_]; i; i = ne[i]) {
    int v_ = v[i];
    if (!dfn[v_]) {
      Tarjan(v_);
      Chkmin(low[u_], low[v_]);
      if (low[v_] >= dfn[u_]) {
        ++ cnt;
        newv[cnt].push_back(u_), newv[u_].push_back(cnt);
        while (true) {
          int top_ = st.top();
          newv[cnt].push_back(top_), newv[top_].push_back(cnt);
          st.pop();
          if (top_ == v_) break;
        }
      }
    } else {
      Chkmin(low[u_], dfn[v_]);
    }
  }
}
namespace Seg {
  #define ls (now_<<1)
  #define rs (now_<<1|1)
  #define mid ((L_+R_)>>1)
  int minv[kN << 2];
  void Pushup(int now_) {
    minv[now_] = std::min(minv[ls], minv[rs]);
  }
  void Build(int now_, int L_, int R_) {
    if (L_ == R_) {
      minv[now_] = val[s[L_]];
      return ;
    }
    Build(ls, L_, mid), Build(rs, mid + 1, R_);
    Pushup(now_);
  }
  void Modify(int now_, int L_, int R_, int pos_, int val_) {
    if (L_ == R_) {
      minv[now_] = val_;
      return ;
    }
    if (pos_ <= mid) Modify(ls, L_, mid, pos_, val_);
    else Modify(rs, mid + 1, R_, pos_, val_);
    Pushup(now_);
  }
  int Query(int now_, int L_, int R_, int l_, int r_) {
    if (l_ <= L_ && R_ <= r_) return minv[now_];
    int ret = kInf;
    if (l_ <= mid) Chkmin(ret, Query(ls, L_, mid, l_, r_));
    if (r_ > mid) Chkmin(ret, Query(rs, mid + 1, R_, l_, r_));
    return ret;
  }
  #undef ls
  #undef rs
  #undef mid
}
namespace HLD {
  int son[kN], dep[kN], sz[kN], top[kN];
  void Dfs1(int u_, int fa_) {
    fa[u_] = fa_, sz[u_] = 1, dep[u_] = dep[fa_] + 1;
    for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
      int v_ = newv[u_][i];
      if (v_ == fa_) continue ;
      Dfs1(v_, u_);
      if (sz[v_] > sz[son[u_]]) son[u_] = v_;
      sz[u_] += sz[v_];
      if (u_ > n) minval[u_].insert(val[v_]);
    }
    if (u_ > n) val[u_] = *minval[u_].begin();
  }
  void Dfs2(int u_, int top_) {
    hld_dfn[u_] = ++ hld_dfnnum;
    s[hld_dfnnum] = u_;
    top[u_] = top_;
    if (son[u_]) Dfs2(son[u_], top_);
    for (int i = 0, lim = newv[u_].size(); i < lim; ++ i) {
      int v_ = newv[u_][i];
      if (v_ == fa[u_] || v_ == son[u_]) continue ;
      Dfs2(v_, v_);
    }
  }
  int Query(int u_, int v_) {
    int ret = kInf;
    for (; top[u_] != top[v_]; u_ = fa[top[u_]]) {
      if (dep[top[u_]] < dep[top[v_]]) {
        std::swap(u_, v_);
      }
      Chkmin(ret, Seg::Query(1, 1, cnt, hld_dfn[top[u_]], hld_dfn[u_]));
    }
    int lca = dep[u_] < dep[v_] ? u_ : v_;
    if (lca != v_) std::swap(u_, v_);
    Chkmin(ret, Seg::Query(1, 1, cnt, hld_dfn[lca], hld_dfn[u_]));
    if (lca > n) Chkmin(ret, val[fa[lca]]);
    return ret;
  }
  void Init() {
    HLD::Dfs1(1, 0), HLD::Dfs2(1, 1), Seg::Build(1, 1, cnt);
  }
}
void Modify(int u_, int val_) { //单点修改
  int f = fa[u_];
  if (f) minval[f].erase(val[u_]); //更新父亲的最小权值集合
  Seg::Modify(1, 1, cnt, hld_dfn[u_], val[u_] = val_); //修改圆点
  if (f) {
    minval[f].insert(val[u_]); //修改方点
    Seg::Modify(1, 1, cnt, hld_dfn[f], val[f] = *minval[f].begin());
  }
}
int Query(int u_, int v_) {
  return HLD::Query(u_, v_);
}
//=============================================================
int main() { 
  cnt = n = read(), m = read(), q = read();
  for (int i = 1; i <= n; ++ i) val[i] = read();
  for (int i = 1; i <= m; ++ i) {
    int u_ = read(), v_ = read();
    Add(u_, v_), Add(v_, u_);
  }
  for (int i = 1; i <= n; ++ i) {
    if (!dfn[i]) {
      Tarjan(i);
    }
  }
  HLD::Init();
  for (int i = 1; i <= q; ++ i) {
    char opt[5]; scanf("%s", opt);
    if (opt[0] == 'C') {
      int pos_ = read(), val_ = read();
      Modify(pos_, val_);
    } else {
      int u_ = read(), v_ = read();
      printf("%d\n", Query(u_, v_));
    }
  }
  return 0; 
}

写在最后

鸣谢：

圆方树 - OI Wiki
圆方树——处理仙人掌的利器 - immortalCO
《算法竞赛进阶指南》
WC2018讲课论文圆方树simple_immortalCO^[1:1]
点双连通分量 & 圆方树学习笔记 - RainAir's Blog

如果需要该课件可以通过该链接下载：https://files.cnblogs.com/files/luckyblock/%E5%9C%86%E6%96%B9%E6%A0%91simple_immortalCO.zip。 ↩︎ ↩︎

posted @ 2021-02-24 17:12 Luckyblock 阅读(3097) 评论(8) 编辑收藏举报

刷新页面返回顶部

Luckyblock

身与华落，心将香飞