Mining Your Own Business 点双连通分量

最新推荐文章于 2020-11-02 12:49:39 发布

原创最新推荐文章于 2020-11-02 12:49:39 发布 · 380 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

大三ACM - 图专栏收录该内容

78 篇文章

订阅专栏

本文详细解析了一道关于点双联通性的复杂问题，通过总结关键步骤解决了如何在图中找到割点并确保人群能安全到达地面的问题。文章还提供了一个实用的点双联通算法模板。

好难的一道题...查了一下居然是世界赛的题目..Σ( ° △ °|||)︴

①首先要用点联通，不要用边联通，因为我们这次看的是点。

②缩点并统计整个图一共有多少的割点。

③如果割点为0，那么我们需要随便建立两个即可，因为可以互相到达。不建一个是因为怕那个点正好被炸了。

④如果割点大于0，我们统计每个点联通分量（每个联通分量当中的点是可以互相到达的）。如果某个点联通分量中割点数等于1，那么我们需要建立当前点联通分量点的数量-1个。因为这个割点一旦被毁了，整个图都会被会的七零八碎的，只有每个位置都建立一个才安全。去过割点数大于1了，那么我们不需要建。因为只能毁灭一个点，假设毁的是一个割点，但是另一个割点还存在，割点的定义是毁了它，整个图就不连通了，但是只要不毁，就是联通的。所以只要有任何一个割点没毁，这个图就还是连通的，人群可以通过没毁的前往其他连通图到达地面。所以，如果某个连通分量割点大于1，那么不需要建立。注意：每个联通分量之间要用乘法！。

这道题主要是想到要用点双联通，之后总结一下三四条规律，套个模板就出来了。

附一个很好用的点双联通的模板

#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;
const int MAXNODE = 10005;
const int MAXEDGE = 100010;
const int INF = 0x3f3f3f3f;

struct Edge{
int v, id, next;
bool bridge;
Edge() {}
Edge(int v, int id, int next): v(v), id(id), next(next), bridge(false){}
}E[MAXEDGE * 2], cut[MAXEDGE];

struct Node {
int u, v;
Node() {}
Node(int u, int v): u(u), v(v) {}
};

stack<Node> Stack;
//bcc表示的是一个bcc里面的点
vector<int> bcc[MAXNODE];
//pre纪录的是时间戳,lowlink纪录的是该点及其该子孙节点所能返回的最早时间戳是多少,bccno纪录的是该点当前是属于哪个bcc的
int head[MAXNODE], pre[MAXNODE], lowlink[MAXNODE], bccno[MAXNODE];
int n, m, tot, bcc_cnt, dfs_clock, cut_cnt;
bool iscut[MAXNODE];

//双向边的添加
void AddEdge(int u, int v, int id) {
E[tot] = Edge(v, id, head[u]);
head[u] = tot++;
E[tot] = Edge(u, id, head[v]);
head[v] = tot++;
}

void init() {
memset(head, -1, sizeof(head));
tot = 0;
}

//点双连通
void dfs(int u, int fa) {
pre[u] = lowlink[u] = ++dfs_clock;
int child = 0;//纪录当前节点有多少个子节点
for (int i = head[u]; ~i; i = E[i].next) {
int v = E[i].v;
if (!pre[v]) {
Stack.push(Node(u, v));
child++;
dfs(v, u);
lowlink[u] = min(lowlink[u], lowlink[v]);//更新
//子节点最多返回到该点
if (lowlink[v] >= pre[u]) {
//该边为桥
if (lowlink[v] > pre[u]) {
E[i].bridge = E[i ^ 1].bridge = true;
cut[cut_cnt++] = E[i];
}
iscut[u] = true;
bcc_cnt++; bcc[bcc_cnt].clear();
while (1) {
Node x = Stack.top(); Stack.pop();
if (bccno[x.u] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.u);
bccno[x.u] = bcc_cnt;
}
if (bccno[x.v] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.v);
bccno[x.v] = bcc_cnt;
}
if (x.u == u && x.v == v) break;
}
}
}
else if (v != fa && pre[v] < pre[u]) {//反向边
Stack.push(Node(u, v));
lowlink[u] = min(lowlink[u], pre[v]);
}
}
//u是根结点，且只有一个孩子，那就不是割点了
if (fa < 0 && child == 1) iscut[u] = 0;
}

void find_bcc() {
memset(pre, 0, sizeof(pre));
memset(iscut, 0, sizeof(iscut));
memset(bccno, 0, sizeof(bccno));
dfs_clock = bcc_cnt = cut_cnt = 0;
for (int i = 0; i < n; i++)
if (!pre[i]) dfs(i, -1);
}

int main() {
init();
return 0;
}