AtCoder problem 021

C++ solution:
#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;



// Input

int N, M;

int A[1 << 18], B[1 << 18];



// Graph

bool used[1 << 18];

vector<int> G[1 << 18];

vector<int> H[1 << 18];

vector<int> I;

long long cnts = 0;



void dfs(int pos) {

	used[pos] = true;

	for (int i : G[pos]) {

		if (used[i] == false) dfs(i);

	}

	I.push_back(pos);

}



void dfs2(int pos) {

	used[pos] = true;

	cnts++;

	for (int i : H[pos]) {

		if (used[i] == false) dfs2(i);

	}

}



int main() {

	// Step #1. Input

	cin >> N >> M;

	for (int i = 1; i <= M; i++) {

		cin >> A[i] >> B[i];

		G[A[i]].push_back(B[i]);

		H[B[i]].push_back(A[i]);

	}



	// Step #2. First DFS

	for (int i = 1; i <= N; i++) {

		if (used[i] == false) dfs(i);

	}



	// Step #3. Second DFS

	long long Answer = 0;

	reverse(I.begin(), I.end());

	for (int i = 1; i <= N; i++) used[i] = false;

	for (int i : I) {

		if (used[i] == true) continue;

		cnts = 0;

		dfs2(i);

		Answer += cnts * (cnts - 1LL) / 2LL;

	}



	// Step #4. Output The Answer!

	cout << Answer << endl;

	return 0;

}

Crystal solution: # ac-library.cr by hakatashi https://github.com/google/ac-library.cr
#
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

module AtCoder
  # Implements [atcoder::scc_graph](https://atcoder.github.io/ac-library/master/document_en/scc.html).
  #
  # ```
  # scc = AtCoder::SCC.new(3_i64)
  # scc.add_edge(0, 1)
  # scc.add_edge(1, 0)
  # scc.add_edge(2, 0)
  # scc.scc # => [Set{2}, Set{0, 1}]
  # ```
  class SCC
    alias Adjacency = NamedTuple(in: Array(Int64), out: Array(Int64))

    getter size : Int64
    getter adjacencies : Array(Adjacency)

    def initialize(@size)
      @adjacencies = Array(Adjacency).new(@size) { {in: [] of Int64, out: [] of Int64} }

      @topological_order = Array(Int64).new(@size)
      @visit_counts = Array(Int64).new(@size, 0_i64)
      @visited = Set(Int64).new
      @stack = Deque(Int64).new
      @groups = Array(Set(Int64)).new
    end

    # Implements atcoder::scc_graph.add_edge(from, to).
    def add_edge(from, to)
      @adjacencies[from][:out] << to.to_i64
      @adjacencies[to][:in] << from.to_i64
    end

    private def dfs(start)
      @stack << start
      @visited << start

      until @stack.empty?
        node = @stack.last
        children = @adjacencies[node][:out]

        if @visit_counts[node] < children.size
          child = children[@visit_counts[node]]
          @visit_counts[node] += 1

          unless @visited.includes?(child)
            @visited << child
            @stack << child
          end
        else
          @topological_order << node
          @stack.pop
        end
      end
    end

    private def reverse_dfs(start)
      @stack << start
      @visited << start
      group = Set{start}

      until @stack.empty?
        node = @stack.pop
        children = @adjacencies[node][:in]

        children.each do |child|
          unless @visited.includes?(child)
            @stack << child
            @visited << child
            group << child
          end
        end
      end

      @groups << group
    end

    # Implements atcoder::scc_graph.scc().
    def scc
      @visited = Set(Int64).new
      @stack = Deque(Int64).new
      @visit_counts = Array(Int64).new(@size, 0_i64)
      @topological_order = Array(Int64).new(@size)
      @groups = Array(Set(Int64)).new

      @size.times do |node|
        unless @visited.includes?(node)
          dfs(node)
        end
      end

      @visited = Set(Int64).new

      @topological_order.reverse_each do |node|
        unless @visited.includes?(node)
          reverse_dfs(node)
        end
      end

      @groups
    end
  end
end

n, m = read_line.split.map(&.to_i)
scc = AtCoder::SCC.new(n.to_i64)
m.times do
  a, b = read_line.split.map(&.to_i.pred)
  scc.add_edge(a, b)
end
puts scc.scc.sum { |group|
  i = group.size.to_i64
  i * i.pred // 2
}