Add scc

Author: adamant-pwn

cp-algo/graph/scc.hpp

@@ -0,0 +1,52 @@
+#ifndef CP_ALGO_GRAPH_SCC_HPP
+#define CP_ALGO_GRAPH_SCC_HPP
+#include "base.hpp"
+#include "../structures/csr.hpp"
+#include <algorithm>
+namespace cp_algo::graph {
+    // Tarjan's algorithm for Strongly Connected Components
+    // returns components in reverse topological order
+    template<digraph_type 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 };
+        std::vector<node_state> state(g.n());
+        auto collect = [&](this auto &&collect, node_index v) -> void {
+            state[v] = collected;
+            components.push(v);
+            for(auto e: g.outgoing(v)) {
+                node_index u = g.edge(e).to;
+                if (state[u] != collected) {
+                    collect(u);
+                }
+            }
+        };
+        big_vector<int> tin(g.n()), low(g.n());
+        int timer = 0;
+        auto dfs = [&](this auto &&dfs, node_index v) -> void {
+            state[v] = visited;
+            tin[v] = low[v] = timer++;
+            for(auto e: g.outgoing(v)) {
+                node_index u = g.edge(e).to;
+                if (state[u] == unvisited) {
+                    dfs(u);
+                    low[v] = std::min(low[v], low[u]);
+                } else if (state[u] == visited) {
+                    low[v] = std::min(low[v], tin[u]);
+                }
+            }
+            if (low[v] == tin[v]) {
+                components.new_row();
+                collect(v);
+            }
+        };
+        for (auto v: g.nodes()) {
+            if (state[v] == unvisited) {
+                dfs(v);
+            }
+        }
+        return components;
+    }
+}
+#endif // CP_ALGO_GRAPH_SCC_HPP

cp-algo/structures/csr.hpp

@@ -0,0 +1,59 @@
+#ifndef CP_ALGO_STRUCTURES_CSR_HPP
+#define CP_ALGO_STRUCTURES_CSR_HPP
+#include "../util/big_alloc.hpp"
+#include <algorithm>
+#include <numeric>
+#include <ranges>
+#include <span>
+namespace cp_algo::structures {
+    template<class datatype>
+    struct csr {
+        csr(): head{0} { }
+
+        void new_row() {
+            head.push_back(head.back());
+        }
+
+        void push(datatype const& value) {
+            data.push_back(value);
+            head.back()++;
+        }
+
+        template<typename... Args>
+        void emplace(Args&&... args) {
+            data.emplace_back(std::forward<Args>(args)...);
+            head.back()++;
+        }
+
+        void reserve_rows(int n) {
+            head.reserve(n + 1);
+        }
+
+        void reserve_data(size_t n) {
+            data.reserve(n);
+        }
+
+        void reverse_rows() {
+            std::ranges::reverse(data);
+            std::adjacent_difference(head.begin(), head.end(), head.begin());
+            std::ranges::reverse(head | std::views::drop(1));
+            std::partial_sum(head.begin(), head.end(), head.begin());
+        }
+
+        size_t size() const { return head.size() - 1; }
+        size_t total_size() const { return data.size(); }
+
+        auto operator[](this auto&& self, auto row) {
+            return std::span(self.data).subspan(self.head[row], self.head[row + 1] - self.head[row]);
+        }
+
+        auto rows(this auto&& self) {
+            return std::views::iota(size_t(0), self.size()) 
+                 | std::views::transform([&self](auto i) { return self[i]; });
+        }
+
+        big_vector<int> head;
+        big_vector<datatype> data;
+    };
+}
+#endif // CP_ALGO_STRUCTURES_CSR_HPP

verify/graph/scc.test.cpp

@@ -0,0 +1,37 @@
+// @brief Strongly Connected Components
+#define PROBLEM "https://judge.yosupo.jp/problem/scc"
+#pragma GCC optimize("Ofast,unroll-loops")
+#include <iostream>
+#include "blazingio/blazingio.min.hpp"
+#include "cp-algo/graph/scc.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m;
+    cin >> n >> m;
+    digraph g(n);
+    g.read_edges(m);
+    auto comps = scc(g);
+    cout << size(comps) << '\n';
+    for(auto const& comp: comps.rows() | views::reverse) {
+        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();
+    }
+}