Problem:
Score : 500 points

Problem Statement

N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.

The tournament is round-robin format, and there will be N(N-1)/2 matches in total.
Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.

Each player plays at most one matches in a day.

Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.

Constraints

3 \leq N \leq 1000

1 \leq A_{i, j} \leq N

A_{i, j} \neq i

A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.

Input

Input is given from Standard Input in the following format:

N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}

Output

If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print -1.

Sample Input 1

3
2 3
1 3
1 2

Sample Output 1

3

All the conditions can be satisfied if the matches are scheduled for three days as follows:

Day 1: Player 1 vs Player 2

Day 2: Player 1 vs Player 3

Day 3: Player 2 vs Player 3

This is the minimum number of days required.

Sample Input 2

4
2 3 4
1 3 4
4 1 2
3 1 2

Sample Output 2

4

All the conditions can be satisfied if the matches are scheduled for four days as follows:

Day 1: Player 1 vs Player 2, Player 3 vs Player 4

Day 2: Player 1 vs Player 3

Day 3: Player 1 vs Player 4, Player 2 vs Player 3

Day 4: Player 2 vs Player 4

This is the minimum number of days required.

Sample Input 3

3
2 3
3 1
1 2

Sample Output 3

-1

Any scheduling of the matches violates some condition.

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using BitArray = System.Collections.BitArray;
using BigInteger = System.Numerics.BigInteger;
using TextReader = System.IO.TextReader;
using System.Text;

namespace AtCoderProject
{
    public class Program
    {
        public object Calc()
        {
            var N = consoleReader.Int;
            var a = consoleReader.Repeat(N).Select(cr => cr.Split.Int0).ToArray();
            var matchNum = N * (N - 1) / 2;
            var gb = new GraphBuilder(matchNum);
            for (int i = 0; i < N; i++)
            {
                int prevMatch, currentMatch;
                prevMatch = MatchNumber(i, a[i][0], N);
                for (int j = 1; j < N - 1; j++)
                {
                    currentMatch = MatchNumber(i, a[i][j], N);
                    gb.Add(prevMatch, currentMatch);
                    prevMatch = currentMatch;
                }
            }

            graph = gb.nodes;
            cache = new int[matchNum];
            var max = graph.Max(n => Calc(n.index, -1));
            if (max == int.MaxValue)
                max = -1;
            return max;
        }
        int Calc(int index, int from)
        {
            if (cache[index] > 0) return cache[index];
            if (index == from) return int.MaxValue;

            if (from == -1)
                from = index;

            int result;
            if (graph[index].children.Count == 0)
            {
                result = 1;
            }
            else
            {
                var max = 0;
                foreach (var child in graph[index].children)
                {
                    var cur = Calc(child, from);
                    if (cur == int.MaxValue)
                        return cache[index] = int.MaxValue;
                    else if (max < cur)
                        max = cur;
                }
                result = max + 1;
            }

            return cache[index] = result;
        }
        Node[] graph;
        int[] cache;
        static int MatchNumber(int a, int b, int N)
        {
            if (a == b) throw new Exception();
            else if (a > b) return MatchNumber(b, a, N);
            return a * N + b - (a + 1) * (a + 2) / 2;
        }

        class GraphBuilder
        {
            public Node[] nodes;
            public GraphBuilder(int count)
            {
                this.nodes = new Node[count];
                for (int i = 0; i < count; i++)
                    this.nodes[i] = new Node(i);
            }
            public GraphBuilder(int count, IEnumerable<int[]> arrays) : this(count)
            {
                foreach (var item in arrays)
                    this.Add(item[0], item[1]);
            }
            public void Add(int from, int to)
            {
                nodes[from].children.Add(to);
                nodes[to].roots.Add(from);
            }
        }
        public struct Node : IEquatable<Node>
        {
            public Node(int i)
            {
                this.index = i;
                this.roots = new HashSet<int>();
                this.children = new HashSet<int>();
            }
            public int index;
            public HashSet<int> roots;
            public HashSet<int> children;

            public override bool Equals(object obj)
            {
                if (obj is Node)
                    return this.Equals((Node)obj);
                else
                    return false;
            }
            public bool Equals(Node other) => this.index == other.index;
            public override int GetHashCode() => this.index;
        }

        #region いつもの
        private readonly ConsoleReader consoleReader;
        public Program(ConsoleReader consoleReader) { this.consoleReader = consoleReader; }
        static void Main() => Console.WriteLine(new Program(new ConsoleReader(Console.In)).Calc()); static string AllLines<T>(IEnumerable<T> source) => string.Join("\n", source);
        #endregion
    }
#pragma warning disable
    public class ConsoleReader
    {
        private string[] ReadLineSplit() => textReader.ReadLine().Split(Array.Empty<char>(), StringSplitOptions.RemoveEmptyEntries);
        private string[] line = Array.Empty<string>();
        private int linePosition;
        private TextReader textReader;
        public ConsoleReader(TextReader tr) { textReader = tr; }
        public int Int => int.Parse(String);
        public long Long => long.Parse(String);
        public double Double => double.Parse(String);
        public string String
        {
            get
            {
                if (linePosition >= line.Length)
                {
                    linePosition = 0;
                    line = ReadLineSplit();
                }
                return line[linePosition++];
            }
        }
        public class SplitLine
        {
            private string[] splited;
            public SplitLine(ConsoleReader cr) { splited = cr.ReadLineSplit(); cr.line = Array.Empty<string>(); }
            public int[] Int => String.Select(x => int.Parse(x)).ToArray();
            public int[] Int0 => String.Select(x => int.Parse(x) - 1).ToArray();
            public long[] Long => String.Select(x => long.Parse(x)).ToArray();
            public double[] Double => String.Select(x => double.Parse(x)).ToArray();
            public string[] String => splited;
        }
        public SplitLine Split => new SplitLine(this);
        public class RepeatReader : IEnumerable<ConsoleReader>
        {
            ConsoleReader cr; int count;
            public RepeatReader(ConsoleReader cr, int count) { this.cr = cr; this.count = count; }
            public IEnumerator<ConsoleReader> GetEnumerator() => Enumerable.Repeat(cr, count).GetEnumerator();
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();

            public IEnumerable<string> String => this.Select(cr => cr.String);
            public IEnumerable<int> Int => this.Select(cr => cr.Int);
            public IEnumerable<int> Int0 => this.Select(cr => cr.Int - 1);
            public IEnumerable<long> Long => this.Select(cr => cr.Long);
            public IEnumerable<double> Double => this.Select(cr => cr.Double);
        }
        public RepeatReader Repeat(int count) => new RepeatReader(this, count);
    }
}