Problem:
Score : 700 points

Problem Statement

Limak can repeatedly remove one of the first two characters of a string,
for example abcxyx \rightarrow acxyx \rightarrow cxyx \rightarrow cyx.

You are given N different strings S_1, S_2, \ldots, S_N.
Among N \cdot (N-1) / 2 pairs (S_i, S_j),
in how many pairs could Limak obtain one string from the other?

Constraints

2 \leq N \leq 200\,000

S_i consists of lowercase English letters a-z.

S_i \neq S_j

1 \leq |S_i|

|S_1| + |S_2| + \ldots + |S_N| \leq 10^6

Input

Input is given from Standard Input in the following format.

N
S_1
S_2
\vdots
S_N

Output

Print the number of unordered pairs (S_i, S_j)
where i \neq j and Limak can obtain one string from the other.

Sample Input 1

3
abcxyx
cyx
abc

Sample Output 1

1

The only good pair is (abcxyx, cyx).

Sample Input 2

6
b
a
abc
c
d
ab

Sample Output 2

5

There are five good pairs: (b, abc), (a, abc), (abc, c), (b, ab), (a, ab).

Solution in Ruby (2.7.1) (judge verdict: Time Limit Exceeded)

#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

var_to_int = [*'a'..'z'].each_with_object({}).with_index do |(cur, sum), index|
  sum[cur] = 2 ** index
end

N = get_int
S = []
N.times do |i|
  S[i] = gets.chomp
end

S.sort! { |a, b| a.length <=> b.length }

count = 0
hash = Hash.new { |h,k| h[k] = 0 }
S.each do |s|
  set = 0
  0.step(s.length-1) do |i|
    set |= var_to_int[s[i]]
    rest = s[(i+1)..]
    if i == 0
      hash[rest] |= var_to_int[s[i]]
    else
      test = 1
      v = hash[rest]
      while test <= v || test <= set
        count += 1 if v & test > 0 && set & test > 0
        test *= 2
      end
      # count += counting_1bits(hash[rest] & set)
    end
  end
end

p count

# count = 0
# hash = Hash.new { |h,k| h[k] = Set.new }
# S.each do |s|
#   set = Set.new
#   0.step(s.length-1) do |i|
#     set.add(s[i])
#     rest = s[(i+1)..]
#     count += (hash[rest] & set).length
#   end
#
#   first, *rest = s.split('')
#   hash[rest.join].add(first)
# end
#
# p count