Problem:
Score : 600 points

Problem Statement

We have 3N cards arranged in a row from left to right, where each card has an integer between 1 and N (inclusive) written on it. The integer written on the i-th card from the left is A_i.

You will do the following operation N-1 times:

Rearrange the five leftmost cards in any order you like, then remove the three leftmost cards. If the integers written on those three cards are all equal, you gain 1 point.

After these N-1 operations, if the integers written on the remaining three cards are all equal, you will gain 1 additional point.

Find the maximum number of points you can gain.

Constraints

1 \leq N \leq 2000

1 \leq A_i \leq N

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_{3N}

Output

Print the maximum number of points you can gain.

Sample Input 1

2
1 2 1 2 2 1

Sample Output 1

2

Let us rearrange the five leftmost cards so that the integers written on the six cards will be 2\ 2\ 2\ 1\ 1\ 1 from left to right.

Then, remove the three leftmost cards, all of which have the same integer 2, gaining 1 point.

Now, the integers written on the remaining cards are 1\ 1\ 1.

Since these three cards have the same integer 1, we gain 1 more point.

In this way, we can gain 2 points - which is the maximum possible.

Sample Input 2

3
1 1 2 2 3 3 3 2 1

Sample Output 2

1

Sample Input 3

3
1 1 2 2 2 3 3 3 1

Sample Output 3

3

Solution in Ruby (2.7.1) (judge verdict: Wrong Answer)

N = gets.to_i
As = gets.split.map{_1.to_i - 1}
INF = 10**10

f = ->(a, b){a*N + b}
ma = ->(a, b){a > b ? a : b}
dp = Array.new(N*N, -INF)
m1, m2 = Array.new(N, -INF), Array.new(N, -INF)
m, ans = 0, 0
dp[f[*As.take(2)]] = 0
m1[As[0]], m2[As[1]] = 0, 0
upd = []
(1 ... N).each do |i|
  as = As[3*i - 1, 3]
  if as.uniq.one?
    ans += 1
  else
    a, b, c = as
    if as.uniq.size == 2
      x = (a == b || a == c) ? a : b
      y = a == b ? c : a == c ? b : a
      (0 ... N).each{|j| upd << [j, y, ma[dp[f[x, j]], dp[f[j, x]] + 1]]}
    end
    upd << [b, c, dp[f[a, a]] + 1] << [a, c, dp[f[b, b]] + 1] << [a, b, dp[f[c, c]] + 1]
    upd << [a, b, m] << [a, c, m] << [b, c, m]
    (0 ... N).each do |j|
      upd << [j, a, ma[m1[j], m2[j]]] << [j, b, ma[m1[j], m2[j]]] << [j, c, ma[m1[j], m2[j]]]
    end
    upd.each do |j, k, v|
      dp[f[j, k]] = ma[dp[f[j, k]], v]
      m1[j] = ma[m1[j], dp[f[j, k]]]
      m2[k] = ma[m2[k], dp[f[j, k]]]
      m = ma[m, dp[f[j, k]]]
    end
    upd = []
  end
end
puts ans + ma[m, dp[f[As.last, As.last]] + 1]