#include<iostream>
#include<fstream>
#include<cstring>
using namespace std;

int n, f[256][256], a[256][256], dist[256], pred[256];

// Funcție pentru implementarea algoritmului lui Bellman-Ford
int bellman() {
  memset(pred, -1, sizeof(pred));
  memset(dist, 0x3f3f, sizeof(dist));
  dist[0] = 0;
  pred[0] = 0;

  int i, j, ok = 1;

  while (ok == 1) {
    ok = 0;
    for (i = 0; i <= 2 * n + 1; ++i)
      for (j = 0; j <= 2 * n + 1; ++j)
      //1.Verificăm dacă există un flux între nodul i și nodul j. Dacă valoarea este mai mare decât zero, înseamnă că există un !!flux pe acea muchie.
      //1.Verificăm dacă actualizarea distanței pentru nodul j prin intermediul nodului i ar reduce distanța. 
      //2.Distanța este influențată de capacitatea muchiei și de distanța până la nodul sursă. Dacă această condiție este îndeplinită, se consideră că am găsit o !!cale de creștere.
        if (f[i][j] > 0 && dist[j] > dist[i] + a[i][j]) {
          dist[j] = dist[i] + a[i][j];
          pred[j] = i;
          ok = 1;
        }
  }

  if (pred[2 * n + 1] == -1) return 0;
  return 1;
}

// Funcție pentru calcularea fluxului maxim
void flux() {
  int i, j;
  for (i = 1; i <= n; ++i) {
    f[0][i] = 1; 
    f[n + i][2 * n + 1] = 1;
  }
    while (bellman() == 1) {
        int p = 2 * n + 1;
        while (p) {
        f[pred[p]][p]--;
        f[p][pred[p]]++;
        p = pred[p];
        }
    }
  int sum = 0;
  for (i = 1; i <= n; ++i){
    for (j = n + 1; j <= 2 * n; ++j){
      if (f[i][j]==0) {
      sum += a[i][j];
      }
    }
  }
  ofstream go("cc.out");
  go << sum << endl;
  go.close();
}

int main() {
  ifstream gi("cc.in");
  gi >> n;
  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= n; ++j) {
      gi >> a[i][j + n];
      a[j + n][i] = -a[i][j + n];
      f[i][j + n] = 1;
    }

  gi.close();
  flux();

  return 0;
}