标签:ons set gate 利用 idg bre baidu empty pat
给出一张 \(n\) 个点 \(m\) 条边的无向图,可能不连通、有重边、有自环、有割边。求其所有极大的边三连通分量。
\(n, m \le 5 \times 10 ^ 5\)。
论文太长了,还没看完,目前只看懂了算法步骤,一些证明还咕在后面。就先介绍一下步骤,正确性证明和时间复杂度证明等我看懂以后补上来。附一个论文原地址:A Simple 3-Edge-Connected Component Algorithm,来源选 ResearchGate 那个可以免费下载。
由于这个算法的核心在于其中的 Absort-Eject 操作,我习惯称其为 Absorb-Eject 算法。Absorb-Eject 算法的思想与求点双、边双的 Tarjan 算法类似,都是利用算法过程中建出的 dfs 树,求出点之间的连边情况。故为了更清晰地弄懂这个算法,最好对点双、边双的 Tarjan 算法有一定的理解。
为了减少讨论,我们需要先删除掉原图上一些可有可无,但会导致一些麻烦的分类情况的边:自环和割边。
经过这样预处理转化后,我们将原图变成了若干无自环的边双连通分量的连通块。那么以下的算法过程,均在这样的边双中进行。
首先,对限制条件进行一定的观察:两个点 \(u, v\) 在相同的边三内,当且仅当不存在一个边对 \((e_1, e_2)\),满足将原图的 \(e_1, e_2\) 割开以后,\(u\) 与 \(v\) 不连通。
再加上这张图内没有割边,我们可以定义一个类似割边的定义:切边。我们称一条边 \(e\) 是切边,当且仅当它能够与另外一条边 \(e‘\) 配合,把原图割成两个连通块。那么,对于一条边 \(e = (u, v)\),若 \(e\) 是一条切边,则 \(u, v\) 一定不在一个相同的边三内;若 \(e\) 不是一条切边,则 \(u, v\) 一定在一个相同的边三内。所以我们只需要把原图中所有切边删去,剩下的边就将原图连成了若干边三。
于是我们明确了算法的目的:确定每条边是否为切边。
这个算法的核心步骤是 Absorb-Eject 操作,可译为吞吐操作。Absorb 会在一条边 \((w, u)\) 上进行,表示 \(w\) 将 \(u\) 吞并。吞并时,\(u\) 消失,所有与 \(u\) 相邻的边 \((x, u)\)(除了 \((w, u)\) 以外),都变成与 \(w\) 相邻的边 \((x, w)\)。特殊地,如果 \(u\) 的点度为 \(2\) (注意此时的点度是吞并后形成的新图的点度,而点 \(u\) 也可能已吞并了若干个点),那么可以割开这两条边使得 \(u\) 与外界不连通,说明 \(u\) 及 \(u\) 已吞并过的点是一个单独的边三,就让 \(w\) 将 \(u\) 吐出来,而吐出来的 \(u\) 失去所有相邻的边。
形式化来讲,对于每个点 \(u\),定义其已吞并点集为 \(\sigma(u)\),初始时,\(\sigma(u) = \{u\}\)。进行到目前的图为 \(G‘ = (V‘, E‘)\),进行吞吐的边为 \((w, u)\)。那么进行一次 Absorb-Eject 操作后,图会变成 \(G‘ / e = (V‘‘, E‘‘)\)。其中 \(E‘‘ = E‘ \setminus E_u \cup E_{w ^ +}\),其中 \(E_u\) 表示 \(G‘\) 中与 \(u\) 相邻的边,\(E_{w ^ +} = \{ f‘ = (w, z) \mid \exists f \in E_u,\text{ such that } f = (u, z) \text{ for some } z \in V‘ - \{w\} \}\)。而 \(V‘‘\) 需要分类讨论,若 \(deg_{G‘}(u) = 2\),则 \(u\) 会被 \(w\) 吐出来,那么 \(V‘\) 没变;若 \(deg_{G‘}(u) \neq 2\),则 \(u\) 被 \(w\) 吸收,\(V‘‘ = V‘ - \{u\}\),\(\sigma(w) = \sigma(w) \cup \sigma(u)\)。
由于可以证明(第一个待补证明的坑),若 \(deg_{G‘}(u) \neq 2\),则 \((w, u)\) 一定不是切边,也就是 \(w, u\) 一定在一个边三内。换句话说,就是 \(\sigma(w)\) 就是 \(w\) 所代表的一个原图上的一个边三。在进行若干次吞并后,所有的边都消失了,变成若干独立的点。则每个独立的点就代表着原图上一个极大边三连通分量,就是我们想求的东西。
以上是核心步骤 Absorb-Eject。我们接下来用一个类似 Tarjan 算法的 dfs 过程,配合着 Absorb 操作,将原图一步步变成这样没有边的图,得到每一个表示极大边三连通分量的独立点。
又有一个奇怪的结论(第二个待补证明的坑):递归完一个子树 \(u\) 结束回溯后,子树 \(u\) 内所有仍未确定是否为切边的边形成了一条一端为 \(u\) 的路径,也即修改后的图形成了一条一端为 \(u\) 的路径和若干代表者边三连通分量的独立点。我们称 \(u\) 上挂着的这条路径为 \(u\) - path,记 \(P_u\),我们需要在 dfs 的过程中维护 \(P_u\),最终到达根 \(r\) 时的 \(P_r\) 会为空,也就是再没有未确定是否为切边的边,就结束了我们的算法过程。
dfs 过程中,同样记录 \(low\) 和 \(dfn\),\(dfn(u)\) 表示点 \(u\) 在 dfs 序中的编号,\(low(u)\) 表示 \(u\) 经过最多一条返祖边能到达的 \(dfn\) 最小值,那么有 \(low(w) = \min(\{low(u) \mid u \text{ is a child of } w\} \cup \{ dfn(w‘) \mid (w, w‘) \text{ is a back-edge} \} \cup \{dfn(w)\})\)。我们令此时 dfs 到了一个点 \(w\),枚举其相邻边,分类讨论更新 \(low\) 和 \(P_w\)。
由于 \(low(r) = 1\),所有的树边都会到 \(low(u) \ge low(w)\) 这条,因此 \(P_r\) 保持为空。也就是上面所说的,递归到根结束后,就确定了每条边是否为切边,算法顺利完成。
贴上论文中给出的伪代码:
最后,注意到图变化的时候边不需要显式地维护,只要维护每个点的相邻点度就好了。代码能比较容易地写出来:
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <utility>
#include <vector>
const int MaxN = 500000, MaxM = 500000;
struct graph_t {
int cnte;
int head[MaxN + 5], to[MaxM * 2 + 5], next[MaxM * 2 + 5];
graph_t() { cnte = 1; }
inline void addEdge(int u, int v) {
cnte++; to[cnte] = v;
next[cnte] = head[u]; head[u] = cnte;
}
};
struct union_find {
int par[MaxN + 5];
union_find() { memset(par, -1, sizeof par); }
int find(int x) { return par[x] < 0 ? x : par[x] = find(par[x]); }
inline void merge(int u, int v) {
int p = find(u), q = find(v);
if (p == q) return;
par[p] += par[q];
par[q] = p;
}
};
int N, M;
graph_t Gr;
class two_edge_connect {
private:
int low[MaxN + 5], dfn[MaxN + 5], dfc;
int stk[MaxN + 5], tp;
int bel[MaxN + 5], s;
void dfs(int u, int fe) {
low[u] = dfn[u] = ++dfc;
stk[++tp] = u;
for (int i = Gr.head[u]; i; i = Gr.next[i]) {
if ((i ^ fe) == 1) continue;
int v = Gr.to[i];
if (dfn[v] == 0) {
dfs(v, i);
low[u] = std::min(low[u], low[v]);
} else
low[u] = std::min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
s++;
for (;;) {
int v = stk[tp--];
bel[v] = s;
if (u == v) break;
}
}
}
public:
void init() {
memset(dfn, 0, sizeof dfn);
dfc = tp = s = 0;
for (int i = 1; i <= N; ++i)
if (dfn[i] == 0) dfs(i, 0);
}
inline bool isbridge(int u, int v) {
return bel[u] != bel[v];
}
};
class three_edge_connect {
private:
two_edge_connect bcc;
union_find uf;
int low[MaxN + 5], dfn[MaxN + 5], end[MaxN + 5], dfc;
int deg[MaxN + 5];
inline bool insubtree(int u, int v) {
if (dfn[u] <= dfn[v] && dfn[v] <= end[u]) return true;
else return false;
}
inline void absorb(std::vector<int> &path, int u, int w = 0) {
while (path.empty() == false) {
int v = path.back();
if (w > 0 && insubtree(v, w) == false) break;
path.pop_back();
deg[u] += deg[v] - 2;
uf.merge(u, v);
}
}
void dfs(int u, int fe, std::vector<int> &pu) {
low[u] = dfn[u] = ++dfc;
for (int i = Gr.head[u]; i; i = Gr.next[i]) {
int v = Gr.to[i];
if (u == v || bcc.isbridge(u, v) == true) continue;
deg[u]++;
if ((i ^ fe) == 1) continue;
if (dfn[v] == 0) {
std::vector<int> pv;
dfs(v, i, pv);
if (deg[v] == 2) pv.pop_back();
if (low[v] < low[u]) {
low[u] = low[v];
absorb(pu, u);
pu = pv;
} else absorb(pv, u);
} else {
if (dfn[v] > dfn[u]) {
absorb(pu, u, v);
deg[u] -= 2;
} else if (dfn[v] < low[u]) {
low[u] = dfn[v];
absorb(pu, u);
}
}
}
end[u] = dfc;
pu.push_back(u);
}
public:
void init() {
memset(dfn, 0, sizeof dfn);
memset(deg, 0, sizeof deg);
dfc = 0;
bcc.init();
for (int i = 1; i <= N; ++i) {
if (dfn[i] == 0) {
std::vector<int> pi;
dfs(i, 0, pi);
absorb(pi, i);
}
}
}
std::vector< std::vector<int> > getall() {
std::vector< std::vector<int> > res(N), ans;
for (int i = 1; i <= N; ++i) {
int x = uf.find(i);
res[x - 1].push_back(i);
}
for (int i = 0; i < N; ++i)
if (res[i].empty() == false) ans.push_back(res[i]);
return ans;
}
};
void init() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= M; ++i) {
int u, v;
scanf("%d %d", &u, &v);
Gr.addEdge(u, v);
Gr.addEdge(v, u);
}
}
inline bool cmp(const std::vector<int> &x, const std::vector<int> &y) { return x[0] < y[0]; }
void solve() {
static three_edge_connect tcc;
tcc.init();
std::vector< std::vector<int> > ans = tcc.getall();
for (int i = 0; i < (int) ans.size(); ++i)
std::sort(ans[i].begin(), ans[i].end());
std::sort(ans.begin(), ans.end(), cmp);
printf("%d\n", (int) ans.size());
for (int i = 0; i < (int) ans.size(); ++i) {
int s = (int) ans[i].size();
for (int j = 0; j < s; ++j)
printf("%d%c", ans[i][j], " \n"[j == s - 1]);
}
}
int main() {
init();
solve();
return 0;
}
标签:ons set gate 利用 idg bre baidu empty pat
原文地址:https://www.cnblogs.com/tweetuzki/p/13157847.html