add 2cc, bcc

Author: adamant-pwn

cp-algo/graph/2cc.hpp

@@ -0,0 +1,63 @@
+#ifndef CP_ALGO_GRAPH_2CC_HPP
+#define CP_ALGO_GRAPH_2CC_HPP
+#include "base.hpp"
+#include "../structures/csr.hpp"
+#include <algorithm>
+
+namespace cp_algo::graph {
+    template<undirected_graph_type graph>
+    structures::csr<node_index> two_edge_connected_components(graph const& g) {
+        structures::csr<node_index> components;
+        components.reserve_data(g.n());
+        enum node_state { unvisited, visited, blocked };
+        std::vector<node_state> state(g.n());
+
+        auto collect = [&](this auto &&collect, node_index v) -> void {
+            state[v] = blocked;
+            components.push(v);
+            for (auto e : g.outgoing(v)) {
+                node_index u = g.edge(e).to;
+                if (state[u] != blocked) collect(u);
+            }
+        };
+
+        big_vector<int> tin(g.n()), low(g.n());
+        int timer = 0;
+        auto dfs = [&](this auto &&dfs, node_index v, edge_index ep = -1) -> void {
+            tin[v] = low[v] = timer++;
+            state[v] = blocked;
+            for (auto e: g.outgoing(v)) {
+                if (ep == graph::opposite_idx(e)) {
+                    continue;
+                }
+                node_index u = g.edge(e).to;
+                if (state[u] == unvisited) {
+                    dfs(u, e);
+                    low[v] = std::min(low[v], low[u]);
+                } else {
+                    low[v] = std::min(low[v], tin[u]);
+                }
+            }
+            if (low[v] == tin[v]) {
+                components.new_row();
+                collect(v);
+            } else {
+                state[v] = visited;
+            }
+        };
+
+        for (auto v : g.nodes()) {
+            if (state[v] == unvisited) {
+                if (std::ranges::empty(g.outgoing(v))) {
+                    components.new_row();
+                    components.push(v);
+                } else {
+                    dfs(v);
+                }
+            }
+        }
+        return components;
+    }
+}
+
+#endif // CP_ALGO_GRAPH_2CC_HPP

cp-algo/graph/bcc.hpp

@@ -0,0 +1,63 @@
+#ifndef CP_ALGO_GRAPH_BCC_HPP
+#define CP_ALGO_GRAPH_BCC_HPP
+#include "base.hpp"
+#include "../structures/csr.hpp"
+#include <algorithm>
+
+namespace cp_algo::graph {
+    template<undirected_graph_type graph>
+    structures::csr<node_index> biconnected_components(graph const& g) {
+        structures::csr<node_index> components;
+        components.reserve_data(g.n());
+        enum node_state { unvisited, visited, blocked };
+        std::vector<node_state> state(g.n());
+
+        auto collect = [&](this auto &&collect, node_index v) -> void {
+            state[v] = blocked;
+            components.push(v);
+            for (auto e : g.outgoing(v)) {
+                node_index u = g.edge(e).to;
+                if (state[u] != blocked) collect(u);
+            }
+        };
+
+        big_vector<int> tin(g.n()), low(g.n());
+        int timer = 0;
+        auto dfs = [&](this auto &&dfs, node_index v, edge_index ep = -1) -> void {
+            tin[v] = low[v] = timer++;
+            state[v] = blocked;
+            for (auto e: g.outgoing(v)) {
+                if (ep == graph::opposite_idx(e)) {
+                    continue;
+                }
+                node_index u = g.edge(e).to;
+                if (state[u] == unvisited) {
+                    dfs(u, e);
+                    if (low[u] >= tin[v] && state[u] != blocked) {
+                        components.new_row();
+                        collect(u);
+                        components.push(v);
+                    }
+                    low[v] = std::min(low[v], low[u]);
+                } else {
+                    low[v] = std::min(low[v], tin[u]);
+                }
+            }
+            state[v] = visited;
+        };
+
+        for (auto v : g.nodes()) {
+            if (state[v] == unvisited) {
+                if (std::ranges::empty(g.outgoing(v))) {
+                    components.new_row();
+                    components.push(v);
+                } else {
+                    dfs(v);
+                }
+            }
+        }
+        return components;
+    }
+}
+
+#endif // CP_ALGO_GRAPH_BCC_HPP

cp-algo/graph/scc.hpp

@@ -10,14 +10,14 @@ namespace cp_algo::graph {
     structures::csr<node_index> scc(graph const& g) {
         structures::csr<node_index> components;
         components.reserve_data(g.n());
-        enum node_state { unvisited, visited, collected };
+        enum node_state { unvisited, visited, blocked };
         std::vector<node_state> state(g.n());
         auto collect = [&](this auto &&collect, node_index v) -> void {
-            state[v] = collected;
+            state[v] = blocked;
             components.push(v);
             for(auto e: g.outgoing(v)) {
                 node_index u = g.edge(e).to;
-                if (state[u] != collected) {
+                if (state[u] != blocked) {
                     collect(u);
                 }
             }

verify/graph/2cc.test.cpp

@@ -0,0 +1,37 @@
+// @brief Two-Edge-Connected Components
+#define PROBLEM "https://judge.yosupo.jp/problem/two_edge_connected_components"
+#pragma GCC optimize("Ofast,unroll-loops")
+#include <iostream>
+#include "blazingio/blazingio.min.hpp"
+#include "cp-algo/graph/2cc.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m;
+    cin >> n >> m;
+    graph g(n);
+    g.read_edges(m);
+    auto comps = two_edge_connected_components(g);
+    cout << size(comps) << '\n';
+    for(auto const& comp: comps.rows()) {
+        cout << size(comp) << ' ';
+        for(auto v: comp) {
+            cout << v << ' ';
+        }
+        cout << '\n';
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    //cin >> t;
+    while(t--) {
+        solve();
+    }
+}

verify/graph/bcc.test.cpp

@@ -0,0 +1,37 @@
+// @brief Biconnected Components
+#define PROBLEM "https://judge.yosupo.jp/problem/biconnected_components"
+#pragma GCC optimize("Ofast,unroll-loops")
+#include <iostream>
+#include "blazingio/blazingio.min.hpp"
+#include "cp-algo/graph/bcc.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m;
+    cin >> n >> m;
+    graph g(n);
+    g.read_edges(m);
+    auto comps = biconnected_components(g);
+    cout << size(comps) << '\n';
+    for(auto const& comp: comps.rows()) {
+        cout << size(comp) << ' ';
+        for(auto v: comp) {
+            cout << v << ' ';
+        }
+        cout << '\n';
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    //cin >> t;
+    while(t--) {
+        solve();
+    }
+}