#include<stdio.h>
#include<string.h>

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

// Funcție pentru implementarea algoritmului lui Bellman-Ford
int bellman()
{
  // Inițializează vectorii dist și pred
  memset(pred, -1, sizeof(pred));
  memset(dist, (int)1e9, sizeof(dist));
  dist[0] = 0;
  pred[0] = 0;

  int i, j, ok = 1;

  // Iterează până când nu mai există căi de creștere
  while(ok) {
    ok = 0;
    // Parcurge toate muchiile și actualizează distanțele
    for(i = 0; i <= 2*n+1; ++i)
      for(j = 0; j <= 2*n+1; ++j)
        if (f[i][j] > 0 && dist[j] > dist[i] + a[i][j]) {
          dist[j] = dist[i] + a[i][j];
          pred[j] = i;
          ok = 1;
        }
  }
  
  // Dacă nu există o cale de la sursă la destinație, returnează 0, altfel 1
  if (pred[2*n+1] == -1) return 0;
  return 1;
}

// Funcție pentru calcularea fluxului maxim
void flux()
{
  int i, j;
  // Inițializează fluxurile inițiale
  for(i = 1; i <= n; ++i) f[0][i] = f[n+i][2*n+1] = 1;

  // Execută algoritmul de flux maxim folosind Bellman-Ford
  while(bellman()) {
    int p = 2*n+1;
    // Actualizează fluxurile pe calea de creștere găsită
    while(p) {
      f[pred[p]][p]--;
      f[p][pred[p]]++;
      p = pred[p];
    }
  }

  int sum = 0;
  // Calculează suma costurilor muchiilor în care nu mai este flux
  for(i = 1; i <= n; ++i)
    for(j = n+1; j <= 2*n; ++j)
      if (!f[i][j]) sum += a[i][j];
  
  // Afișează rezultatul
  printf("%d\n", sum);
}

int main()
{
  // Deschide fișierul de intrare
  freopen("cc.in", "r", stdin);
  
  // Citeste numărul de noduri
  scanf("%d", &n);
  
  // Citeste capacitățile muchiilor și inițializează graful
  for(int i = 1; i <= n; ++i)
    for(int j = 1; j <= n; ++j) {
      scanf("%d", &a[i][j+n]);
      a[j+n][i] = -a[i][j+n];
      f[i][j+n] = 1;
    }

  // Deschide fișierul de ieșire
  freopen("cc.out", "w", stdout);
  
  // Rezolvă problema și afișează rezultatul
  flux();

  return 0;
}