AtCoder problem 021

C++ solution:

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
}





Kuin solution: func main()
	var n: int :: cui@inputInt()
	var m: int :: cui@inputInt()
	var ab: []list<int> :: #[n]list<int>
	var ba: []list<int> :: #[n]list<int>
	for i(0, n - 1)
		do ab[i] :: #list<int>
		do ba[i] :: #list<int>
	end for
	for(1, m)
		var a: int :: cui@inputInt() - 1
		var b: int :: cui@inputInt() - 1
		do ab[a].add(b)
		do ba[b].add(a)
	end for
	
	var used1: []bool :: #[n]bool
	var ordersList: list<int> :: #list<int>
	for i(0, n - 1)
		if(!used1[i])
			do dfs1(ab, used1, i, ordersList)
		end if
	end for
	var orders: []int :: ordersList.toArray()
	do orders.reverse()
	
	var used2: []bool :: #[n]bool
	var ans: int :: 0
	for i(0, n - 1)
		if(!used2[orders[i]])
			var res: int :: dfs2(ba, used2, orders[i])
			do ans :+ res * (res - 1) / 2
		end if
	end for
	do cui@print("\{ans}\n")
	
	func dfs1(ab: []list<int>, used: []bool, u: int, ordersList: list<int>)
		do used[u] :: true
		do ab[u].head()
		for i(0, ^ab[u] - 1)
			var v: int :: ab[u].get()
			if(!used[v])
				do dfs1(ab, used, v, ordersList)
			end if
			do ab[u].next()
		end for
		do ordersList.add(u)
	end func
	
	func dfs2(ba: []list<int>, used: []bool, u: int): int
		var res: int :: 1
		do used[u] :: true
		do ba[u].head()
		for i(0, ^ba[u] - 1)
			var v: int :: ba[u].get()
			if(!used[v])
				do res :+ dfs2(ba, used, v)
			end if
			do ba[u].next()
		end for
		ret res
	end func
end func