Problem p02925 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>

using namespace std;

#define MOD 1000000007
#define REP(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define FOR(i, c)                                                              \
  for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;

template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// グラフ関連
struct Edge { // グラフ
  ll to, cap, rev;
  Edge(ll _to, ll _cap, ll _rev) {
    to = _to;
    cap = _cap;
    rev = _rev;
  }
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
              ll revCap) { // 最大フロー求める Ford-fulkerson
  G[from].push_back(Edge(to, cap, (ll)G[to].size()));
  if (revFlag)
    G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
  // 最大フロー・最小カットの場合逆辺は0にする
}

ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
  if (v == t)
    return f;
  used[v] = true;
  for (int i = 0; i < G[v].size(); ++i) {
    Edge &e = G[v][i];
    if (!used[e.to] && e.cap > 0) {
      ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
      if (d > 0) {
        e.cap -= d;
        G[e.to][e.rev].cap += d;
        return d;
      }
    }
  }
  return 0;
}

ll max_flow(Graph &G, ll s, ll t) {
  ll flow = 0;
  for (;;) {
    vector<bool> used(G.size());
    REP(i, used.size()) used[i] = false;
    ll f = max_flow_dfs(G, s, t, INF, used);
    if (f == 0) {
      return flow;
    }
    flow += f;
  }
}

// 最短経路（負閉路検出）
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
  d.resize(G.size());
  negative.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  REP(i, d.size()) negative[i] = false;
  d[s] = 0;
  REP(k, G.size() - 1) {
    REP(i, G.size()) {
      REP(j, G[i].size()) {
        if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
          d[G[i][j].to] = d[i] + G[i][j].cap;
        }
      }
    }
  }
  REP(k, G.size() - 1) {
    REP(i, G.size()) {
      REP(j, G[i].size()) {
        if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
          d[G[i][j].to] = d[i] + G[i][j].cap;
          negative[G[i][j].to] = true;
        }
        if (negative[i] == true)
          negative[G[i][j].to] = true;
      }
    }
  }
}

// 最短経路(負の辺が含まれているとだめ)
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
  d.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  d[s] = 0;
  priority_queue<P, vector<P>, greater<P>> q;
  q.push(make_pair(0, s));
  while (!q.empty()) {
    P a = q.top();
    q.pop();
    if (d[a.second] < a.first)
      continue;
    REP(i, G[a.second].size()) {
      Edge e = G[a.second][i];
      if (d[e.to] > d[a.second] + e.cap) {
        d[e.to] = d[a.second] + e.cap;
        q.push(make_pair(d[e.to], e.to));
      }
    }
  }
}

// 最短経路問題(01bfs:0,1の辺のみ，O(|E|))
void bfs01(Graph &G, ll s, Array &d) {
  d.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  d[s] = 0;
  deque<ll> deq;
  deq.push_front(s);
  while (deq.size() > 0) {
    ll v = deq.front();
    // cout << v << endl;
    deq.pop_front();
    for (auto e : G[v]) {
      if (d[v] + e.cap < d[e.to]) {
        d[e.to] = d[v] + e.cap;
        if (e.cap == 0) {
          deq.push_front(e.to);
        } else {
          deq.push_back(e.to);
        }
      }
    }
  }
}

// 最短経路(負の辺を含んでいてもOK)
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
  d.resize(G.size());
  REP(i, d.size()) d[i].resize(G.size());
  REP(i, d.size()) {
    REP(j, d[i].size()) { d[i][j] = INF; }
  }
  REP(i, G.size()) {
    REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
  }
  REP(i, G.size()) {
    REP(j, G.size()) {
      REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
    }
  }
}

bool tsort(Graph &graph, Array &order) {
  // トポロジカルソートO(E+V)
  // 閉路検出にも使える
  int n = graph.size(), k = 0;
  Array in(n);
  for (auto &es : graph)
    for (auto &e : es)
      in[e.to]++;
  priority_queue<ll, Array, greater<ll>> que;
  REP(i, n)
  if (in[i] == 0)
    que.push(i);
  while (que.size()) {
    int v = que.top();
    que.pop();
    order.push_back(v);
    for (auto &e : graph[v])
      if (--in[e.to] == 0)
        que.push(e.to);
  }
  if (order.size() != n)
    return false;
  else
    return true;
}

class lca {
public:
  const int n = 0;
  const int log2_n = 0;
  std::vector<std::vector<int>> parent;
  std::vector<int> depth;

  lca() {}

  lca(const Graph &g, int root)
      : n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
        depth(n) {
    dfs(g, root, -1, 0);
    for (int k = 0; k + 1 < log2_n; k++) {
      for (int v = 0; v < (int)g.size(); v++) {
        if (parent[k][v] < 0)
          parent[k + 1][v] = -1;
        else
          parent[k + 1][v] = parent[k][parent[k][v]];
      }
    }
  }

  void dfs(const Graph &g, int v, int p, int d) {
    parent[0][v] = p;
    depth[v] = d;
    for (auto &e : g[v]) {
      if (e.to != p)
        dfs(g, e.to, v, d + 1);
    }
  }

  int get(int u, int v) {
    if (depth[u] > depth[v])
      std::swap(u, v);
    for (int k = 0; k < log2_n; k++) {
      if ((depth[v] - depth[u]) >> k & 1) {
        v = parent[k][v];
      }
    }
    if (u == v)
      return u;
    for (int k = log2_n - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }
    return parent[0][u];
  }
};

class UnionFind {
  vector<int> data;
  int num;

public:
  UnionFind(int size) : data(size, -1), num(size) {}
  bool unionSet(int x, int y) {
    x = root(x);
    y = root(y);
    if (x != y) {
      if (data[y] < data[x])
        swap(x, y);
      data[x] += data[y];
      data[y] = x;
      num--;
    }
    return x != y;
  }
  bool findSet(int x, int y) { return root(x) == root(y); }
  int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
  int size(int x) { return -data[root(x)]; }
  int numSet() { return num; }
};

template <class Abel> struct PotentialUnionFind {
  vector<int> par;
  vector<int> rank;
  vector<Abel> diff_weight;

  PotentialUnionFind(int n = 1, Abel SUM_UNITY = 0) { init(n, SUM_UNITY); }

  void init(int n = 1, Abel SUM_UNITY = 0) {
    par.resize(n);
    rank.resize(n);
    diff_weight.resize(n);
    for (int i = 0; i < n; ++i)
      par[i] = i, rank[i] = 0, diff_weight[i] = SUM_UNITY;
  }

  int root(int x) {
    if (par[x] == x) {
      return x;
    } else {
      int r = root(par[x]);
      diff_weight[x] += diff_weight[par[x]];
      return par[x] = r;
    }
  }

  Abel weight(int x) {
    root(x);
    return diff_weight[x];
  }

  bool issame(int x, int y) { return root(x) == root(y); }

  bool merge(int x, int y, Abel w) {
    w += weight(x);
    w -= weight(y);
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (rank[x] < rank[y])
      swap(x, y), w = -w;
    if (rank[x] == rank[y])
      ++rank[x];
    par[y] = x;
    diff_weight[y] = w;
    return true;
  }

  Abel diff(int x, int y) { return weight(y) - weight(x); }
};

class SumSegTree {
private:
  int _sum(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l)
      return 0; // 交差しない
    if (a <= l && r <= b)
      return dat[k]; // a,l,r,bの順で完全に含まれる
    else {
      int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
      int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
      return s1 + s2;
    }
  }

public:
  int n, height;
  vector<int> dat;

  // 初期化（_nは最大要素数）
  SumSegTree(int _n) {
    n = 1;
    height = 1;
    while (n < _n) {
      n *= 2;
      height++;
    }
    dat = vector<int>(2 * n - 1, 0);
  }

  // 場所i(0-indexed)にxを足す
  void add(int i, int x) {
    i += n - 1; // i番目の葉ノードへ
    dat[i] += x;
    while (i > 0) { // 下から上がっていく
      i = (i - 1) / 2;
      dat[i] += x;
    }
  }

  // 区間[a,b)の総和。ノードk=[l,r)に着目している。
  int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
  ll _find(ll a, ll b, ll k, ll l, ll r) {
    // 区間[l,r)の最小値を持つk番目のノードを探索
    if (r <= a || b <= l)
      return INF; // 交差しない
    if (a <= l && r <= b)
      return dat[k]; // 完全に含む
    else {
      ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
      ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
      return min(s1, s2);
    }
  }

public:
  ll n, height;
  vector<ll> dat;

  // 初期化（_nは最大要素数）
  RmqTree(ll _n) {
    n = 1;
    height = 1;
    while (n < _n) {
      n *= 2;
      height++;
    }
    dat = vector<ll>(2 * n - 1, INF);
  }

  // i番目の値(0-indexed)をxに変更
  void update(ll i, ll x) {
    i += n - 1; // i番目の葉ノードへ
    dat[i] = x;
    while (i > 0) {    // 登りながら更新
      i = (i - 1) / 2; // 親ノードのインデックス
      dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
      // 子ノードの小さい方の値を代入
    }
  }

  // 区間[a,b)の最小値の取得
  ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};

// nCr,nPr,modの逆元
class Combination {
public:
  Array fact; // n！
  Array inv;  // n!の逆元
  ll mod;
  Combination(ll n, ll _mod) {
    mod = _mod;
    fact.resize(n + 1);
    fact[0] = 1;
    REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
    inv.resize(n + 1);
    REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
  }
  // modの逆元
  ll mod_inv(ll x) {
    ll n = mod - 2;
    ll res = 1LL;
    while (n > 0) {
      if (n & 1)
        res = res * x % mod;
      x = x * x % mod;
      n >>= 1;
    }
    return res;
  }
  ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
  ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
  ll nHr(ll n, ll r) {
    // 重複組み合わせ：n種類のものからr個取り出す組み合わせ
    return nCr(r + n - 1, r);
  }
};

// 約数
void divisor(ll n, vector<ll> &ret) {
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(ret.begin(), ret.end());
}

// 素因数分解
void factoring(ll n, map<ll, ll> &mp) {
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      mp[i]++;
      n /= i;
    }
  }
  if (n != 1)
    mp[n]++;
}

// 最大公約数
ll gcd(ll m, ll n) {
  if (n == 0)
    return m;
  return gcd(n, m % n);
} // gcd

// 最小公倍数
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }

// 繰り返し自乗法
ll pow2(ll x, ll n) { // x^n 計算量O(logn)
  ll ans = 1ll;
  while (n > 0) {
    if ((n & 1) == 1) {
      ans = ans * x;
    }
    x = x * x; // 一周する度にx, x^2, x^4, x^8となる
    n >>= 1;   // 桁をずらす n = n >> 1
  }
  return ans;
}
ll pow2_m(ll x, ll n, ll mod) { // x^n 計算量O(logn)
  ll ans = 1ll;
  while (n > 0) {
    if ((n & 1) == 1) {
      ans = ans * x % mod;
    }
    x = x * x % mod; // 一周する度にx, x^2, x^4, x^8となる
    n >>= 1;         // 桁をずらす n = n >> 1
  }
  return ans;
}

vector<ll> lis_fast(const vector<ll> &a) { // 最長部分増加列
  const ll n = a.size();
  vector<ll> A(n, INT_MAX);
  vector<ll> id(n);
  for (int i = 0; i < n; ++i) {
    // id[i] = distance(A.begin(), upper_bound(A.begin(), A.end(),
    // a[i]));//最長部分非減少列
    id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
    A[id[i]] = a[i];
  }
  ll m = *max_element(id.begin(), id.end());
  vector<ll> b(m + 1);
  for (int i = n - 1; i >= 0; --i)
    if (id[i] == m)
      b[m--] = a[i];
  return b;
}

// memo
// output :	fixed  << setprecision(n) <<小数点以下n桁出力
//			setfill('0') << setw(12) <<num 0埋めで12文字出力
// func
// lower_bound(all(a),x):vector aでx以上の要素のイテレータを返す
// upper_bound(all(a,x)):vector aでxより大きい要素のイテレータを返す
//						setやmapの場合は専用関数あり
// 調和関数はlogn! n/1+n/2+n/3+...

ll dp[1000010];

ll dfs(Graph g, ll v) {
  // cout << v << endl;
  if (dp[v] != 0)
    return dp[v];
  if (g[v].size() == 0) {
    dp[v] = 1;
    return dp[v];
  }

  ll ans = 0;
  for (auto e : g[v]) {
    // cout << "b" << e.to << endl;
    chmax(ans, dfs(g, e.to));
  }
  dp[v] = ans + 1;
  return dp[v];
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  ll n;
  cin >> n;

  Graph g(n * n);
  Array used(n * n, false);

  REP(i, n) {
    ll pre, now, a;
    cin >> a;
    a--;
    if (i < a) {
      pre = n * i + a;
    } else {
      pre = n * a + i;
    }
    REP(j, n - 2) {
      cin >> a;
      a--;
      if (i < a) {
        now = n * i + a;
      } else {
        now = n * a + i;
      }
      add_edge(g, pre, now, 1, false, 0);
      // cout << pre << " " << now << endl;
      pre = now;
      used[now] = true;
    }
  }

  ll ans = 0;
  Array order;
  if (tsort(g, order)) {
    REP(i, n) {
      // cout << "a" << i << endl;
      for (int j = i + 1; j < n; j++) {
        ll v = i * n + j;
        if (!used[v]) {
          chmax(ans, dfs(g, v));
        }
      }
    }

  } else {
    cout << -1 << endl;
    return 0;
  }

  cout << ans << endl;

  return 0;
}


Fixed submission:
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>

using namespace std;

#define MOD 1000000007
#define REP(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define FOR(i, c)                                                              \
  for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;

template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// グラフ関連
struct Edge { // グラフ
  ll to, cap, rev;
  Edge(ll _to, ll _cap, ll _rev) {
    to = _to;
    cap = _cap;
    rev = _rev;
  }
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
              ll revCap) { // 最大フロー求める Ford-fulkerson
  G[from].push_back(Edge(to, cap, (ll)G[to].size()));
  if (revFlag)
    G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
  // 最大フロー・最小カットの場合逆辺は0にする
}

ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
  if (v == t)
    return f;
  used[v] = true;
  for (int i = 0; i < G[v].size(); ++i) {
    Edge &e = G[v][i];
    if (!used[e.to] && e.cap > 0) {
      ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
      if (d > 0) {
        e.cap -= d;
        G[e.to][e.rev].cap += d;
        return d;
      }
    }
  }
  return 0;
}

ll max_flow(Graph &G, ll s, ll t) {
  ll flow = 0;
  for (;;) {
    vector<bool> used(G.size());
    REP(i, used.size()) used[i] = false;
    ll f = max_flow_dfs(G, s, t, INF, used);
    if (f == 0) {
      return flow;
    }
    flow += f;
  }
}

// 最短経路（負閉路検出）
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
  d.resize(G.size());
  negative.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  REP(i, d.size()) negative[i] = false;
  d[s] = 0;
  REP(k, G.size() - 1) {
    REP(i, G.size()) {
      REP(j, G[i].size()) {
        if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
          d[G[i][j].to] = d[i] + G[i][j].cap;
        }
      }
    }
  }
  REP(k, G.size() - 1) {
    REP(i, G.size()) {
      REP(j, G[i].size()) {
        if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
          d[G[i][j].to] = d[i] + G[i][j].cap;
          negative[G[i][j].to] = true;
        }
        if (negative[i] == true)
          negative[G[i][j].to] = true;
      }
    }
  }
}

// 最短経路(負の辺が含まれているとだめ)
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
  d.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  d[s] = 0;
  priority_queue<P, vector<P>, greater<P>> q;
  q.push(make_pair(0, s));
  while (!q.empty()) {
    P a = q.top();
    q.pop();
    if (d[a.second] < a.first)
      continue;
    REP(i, G[a.second].size()) {
      Edge e = G[a.second][i];
      if (d[e.to] > d[a.second] + e.cap) {
        d[e.to] = d[a.second] + e.cap;
        q.push(make_pair(d[e.to], e.to));
      }
    }
  }
}

// 最短経路問題(01bfs:0,1の辺のみ，O(|E|))
void bfs01(Graph &G, ll s, Array &d) {
  d.resize(G.size());
  REP(i, d.size()) d[i] = INF;
  d[s] = 0;
  deque<ll> deq;
  deq.push_front(s);
  while (deq.size() > 0) {
    ll v = deq.front();
    // cout << v << endl;
    deq.pop_front();
    for (auto e : G[v]) {
      if (d[v] + e.cap < d[e.to]) {
        d[e.to] = d[v] + e.cap;
        if (e.cap == 0) {
          deq.push_front(e.to);
        } else {
          deq.push_back(e.to);
        }
      }
    }
  }
}

// 最短経路(負の辺を含んでいてもOK)
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
  d.resize(G.size());
  REP(i, d.size()) d[i].resize(G.size());
  REP(i, d.size()) {
    REP(j, d[i].size()) { d[i][j] = INF; }
  }
  REP(i, G.size()) {
    REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
  }
  REP(i, G.size()) {
    REP(j, G.size()) {
      REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
    }
  }
}

bool tsort(Graph &graph, Array &order) {
  // トポロジカルソートO(E+V)
  // 閉路検出にも使える
  int n = graph.size(), k = 0;
  Array in(n);
  for (auto &es : graph)
    for (auto &e : es)
      in[e.to]++;
  priority_queue<ll, Array, greater<ll>> que;
  REP(i, n)
  if (in[i] == 0)
    que.push(i);
  while (que.size()) {
    int v = que.top();
    que.pop();
    order.push_back(v);
    for (auto &e : graph[v])
      if (--in[e.to] == 0)
        que.push(e.to);
  }
  if (order.size() != n)
    return false;
  else
    return true;
}

class lca {
public:
  const int n = 0;
  const int log2_n = 0;
  std::vector<std::vector<int>> parent;
  std::vector<int> depth;

  lca() {}

  lca(const Graph &g, int root)
      : n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
        depth(n) {
    dfs(g, root, -1, 0);
    for (int k = 0; k + 1 < log2_n; k++) {
      for (int v = 0; v < (int)g.size(); v++) {
        if (parent[k][v] < 0)
          parent[k + 1][v] = -1;
        else
          parent[k + 1][v] = parent[k][parent[k][v]];
      }
    }
  }

  void dfs(const Graph &g, int v, int p, int d) {
    parent[0][v] = p;
    depth[v] = d;
    for (auto &e : g[v]) {
      if (e.to != p)
        dfs(g, e.to, v, d + 1);
    }
  }

  int get(int u, int v) {
    if (depth[u] > depth[v])
      std::swap(u, v);
    for (int k = 0; k < log2_n; k++) {
      if ((depth[v] - depth[u]) >> k & 1) {
        v = parent[k][v];
      }
    }
    if (u == v)
      return u;
    for (int k = log2_n - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }
    return parent[0][u];
  }
};

class UnionFind {
  vector<int> data;
  int num;

public:
  UnionFind(int size) : data(size, -1), num(size) {}
  bool unionSet(int x, int y) {
    x = root(x);
    y = root(y);
    if (x != y) {
      if (data[y] < data[x])
        swap(x, y);
      data[x] += data[y];
      data[y] = x;
      num--;
    }
    return x != y;
  }
  bool findSet(int x, int y) { return root(x) == root(y); }
  int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
  int size(int x) { return -data[root(x)]; }
  int numSet() { return num; }
};

template <class Abel> struct PotentialUnionFind {
  vector<int> par;
  vector<int> rank;
  vector<Abel> diff_weight;

  PotentialUnionFind(int n = 1, Abel SUM_UNITY = 0) { init(n, SUM_UNITY); }

  void init(int n = 1, Abel SUM_UNITY = 0) {
    par.resize(n);
    rank.resize(n);
    diff_weight.resize(n);
    for (int i = 0; i < n; ++i)
      par[i] = i, rank[i] = 0, diff_weight[i] = SUM_UNITY;
  }

  int root(int x) {
    if (par[x] == x) {
      return x;
    } else {
      int r = root(par[x]);
      diff_weight[x] += diff_weight[par[x]];
      return par[x] = r;
    }
  }

  Abel weight(int x) {
    root(x);
    return diff_weight[x];
  }

  bool issame(int x, int y) { return root(x) == root(y); }

  bool merge(int x, int y, Abel w) {
    w += weight(x);
    w -= weight(y);
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (rank[x] < rank[y])
      swap(x, y), w = -w;
    if (rank[x] == rank[y])
      ++rank[x];
    par[y] = x;
    diff_weight[y] = w;
    return true;
  }

  Abel diff(int x, int y) { return weight(y) - weight(x); }
};

class SumSegTree {
private:
  int _sum(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l)
      return 0; // 交差しない
    if (a <= l && r <= b)
      return dat[k]; // a,l,r,bの順で完全に含まれる
    else {
      int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
      int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
      return s1 + s2;
    }
  }

public:
  int n, height;
  vector<int> dat;

  // 初期化（_nは最大要素数）
  SumSegTree(int _n) {
    n = 1;
    height = 1;
    while (n < _n) {
      n *= 2;
      height++;
    }
    dat = vector<int>(2 * n - 1, 0);
  }

  // 場所i(0-indexed)にxを足す
  void add(int i, int x) {
    i += n - 1; // i番目の葉ノードへ
    dat[i] += x;
    while (i > 0) { // 下から上がっていく
      i = (i - 1) / 2;
      dat[i] += x;
    }
  }

  // 区間[a,b)の総和。ノードk=[l,r)に着目している。
  int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
  ll _find(ll a, ll b, ll k, ll l, ll r) {
    // 区間[l,r)の最小値を持つk番目のノードを探索
    if (r <= a || b <= l)
      return INF; // 交差しない
    if (a <= l && r <= b)
      return dat[k]; // 完全に含む
    else {
      ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
      ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
      return min(s1, s2);
    }
  }

public:
  ll n, height;
  vector<ll> dat;

  // 初期化（_nは最大要素数）
  RmqTree(ll _n) {
    n = 1;
    height = 1;
    while (n < _n) {
      n *= 2;
      height++;
    }
    dat = vector<ll>(2 * n - 1, INF);
  }

  // i番目の値(0-indexed)をxに変更
  void update(ll i, ll x) {
    i += n - 1; // i番目の葉ノードへ
    dat[i] = x;
    while (i > 0) {    // 登りながら更新
      i = (i - 1) / 2; // 親ノードのインデックス
      dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
      // 子ノードの小さい方の値を代入
    }
  }

  // 区間[a,b)の最小値の取得
  ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};

// nCr,nPr,modの逆元
class Combination {
public:
  Array fact; // n！
  Array inv;  // n!の逆元
  ll mod;
  Combination(ll n, ll _mod) {
    mod = _mod;
    fact.resize(n + 1);
    fact[0] = 1;
    REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
    inv.resize(n + 1);
    REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
  }
  // modの逆元
  ll mod_inv(ll x) {
    ll n = mod - 2;
    ll res = 1LL;
    while (n > 0) {
      if (n & 1)
        res = res * x % mod;
      x = x * x % mod;
      n >>= 1;
    }
    return res;
  }
  ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
  ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
  ll nHr(ll n, ll r) {
    // 重複組み合わせ：n種類のものからr個取り出す組み合わせ
    return nCr(r + n - 1, r);
  }
};

// 約数
void divisor(ll n, vector<ll> &ret) {
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(ret.begin(), ret.end());
}

// 素因数分解
void factoring(ll n, map<ll, ll> &mp) {
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      mp[i]++;
      n /= i;
    }
  }
  if (n != 1)
    mp[n]++;
}

// 最大公約数
ll gcd(ll m, ll n) {
  if (n == 0)
    return m;
  return gcd(n, m % n);
} // gcd

// 最小公倍数
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }

// 繰り返し自乗法
ll pow2(ll x, ll n) { // x^n 計算量O(logn)
  ll ans = 1ll;
  while (n > 0) {
    if ((n & 1) == 1) {
      ans = ans * x;
    }
    x = x * x; // 一周する度にx, x^2, x^4, x^8となる
    n >>= 1;   // 桁をずらす n = n >> 1
  }
  return ans;
}
ll pow2_m(ll x, ll n, ll mod) { // x^n 計算量O(logn)
  ll ans = 1ll;
  while (n > 0) {
    if ((n & 1) == 1) {
      ans = ans * x % mod;
    }
    x = x * x % mod; // 一周する度にx, x^2, x^4, x^8となる
    n >>= 1;         // 桁をずらす n = n >> 1
  }
  return ans;
}

vector<ll> lis_fast(const vector<ll> &a) { // 最長部分増加列
  const ll n = a.size();
  vector<ll> A(n, INT_MAX);
  vector<ll> id(n);
  for (int i = 0; i < n; ++i) {
    // id[i] = distance(A.begin(), upper_bound(A.begin(), A.end(),
    // a[i]));//最長部分非減少列
    id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
    A[id[i]] = a[i];
  }
  ll m = *max_element(id.begin(), id.end());
  vector<ll> b(m + 1);
  for (int i = n - 1; i >= 0; --i)
    if (id[i] == m)
      b[m--] = a[i];
  return b;
}

// memo
// output :	fixed  << setprecision(n) <<小数点以下n桁出力
//			setfill('0') << setw(12) <<num 0埋めで12文字出力
// func
// lower_bound(all(a),x):vector aでx以上の要素のイテレータを返す
// upper_bound(all(a,x)):vector aでxより大きい要素のイテレータを返す
//						setやmapの場合は専用関数あり
// 調和関数はlogn! n/1+n/2+n/3+...

ll dp[1000010];

ll dfs(Graph &g, ll v) {
  // cout << v << endl;
  if (dp[v] != 0)
    return dp[v];
  if (g[v].size() == 0) {
    dp[v] = 1;
    return dp[v];
  }

  ll ans = 0;
  for (auto e : g[v]) {
    // cout << "b" << e.to << endl;
    chmax(ans, dfs(g, e.to));
  }
  dp[v] = ans + 1;
  return dp[v];
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  ll n;
  cin >> n;

  Graph g(n * n);
  Array used(n * n, false);

  REP(i, n) {
    ll pre, now, a;
    cin >> a;
    a--;
    if (i < a) {
      pre = n * i + a;
    } else {
      pre = n * a + i;
    }
    REP(j, n - 2) {
      cin >> a;
      a--;
      if (i < a) {
        now = n * i + a;
      } else {
        now = n * a + i;
      }
      add_edge(g, pre, now, 1, false, 0);
      // cout << pre << " " << now << endl;
      pre = now;
      used[now] = true;
    }
  }

  ll ans = 0;
  Array order;
  if (tsort(g, order)) {
    REP(i, n) {
      // cout << "a" << i << endl;
      for (int j = i + 1; j < n; j++) {
        ll v = i * n + j;
        if (!used[v]) {
          chmax(ans, dfs(g, v));
        }
      }
    }

  } else {
    cout << -1 << endl;
    return 0;
  }

  cout << ans << endl;

  return 0;
}