#include<fstream.h>
#define min(x,y) ((x)<(y)?(x):(y))
#define nx 220
#define inf 10005
int cost[nx][nx],d[nx],heap[nx],pos[nx],tat[nx],cap[nx][nx];
int n,m,drum,s,S,D,L,flux[nx][nx];
void bellmanford()
 {
  int i,j,k,ok=1;
  for (i=0;i<=D;++i) d[i]=inf;
  d[S]=0;
  for (k=1;k<=50 && ok;++k)
   {
    ok=0;
    for (i=0;i<=D;++i)
     for (j=0;j<=D;++j)
      if (cap[i][j]>flux[i][j] && d[j]>d[i]+cost[i][j])
	{
	 d[j]=d[i]+cost[i][j];
	 ok=1;
	}
   }
  s+=d[D];
 }

void up_heap(int x)
 {
  int aux;
  while (x/2>1 && d[heap[x]]<d[heap[x/2]])
   {
    aux=heap[x];
    heap[x]=heap[x/2];
    heap[x/2]=aux;
    pos[heap[x]]=x;
    pos[heap[x/2]]=x/2;
    x/=2;
   }
 }

void down_heap(int x)
 {
  int y=0,aux;
  while (x!=y)
   {
    y=x;
    if (y*2<=L && d[heap[x]]>d[heap[y*2]]) x = y*2;
	if (y*2+1 <= L && d[heap[x]]>d[heap[y*2+1]]) x = y*2+1;

    aux = heap[x], heap[x] = heap[y], heap[y] = aux;
    pos[heap[x]]=x;
    pos[heap[y]]=y;
   }
 }

int dijkstra()
 {
  int i,j,r;
  for (i=0;i<=D;++i)
   for (j=0;j<=D;++j)
    if (d[i]!=inf && d[j]!=inf)
       cost[i][j]+=d[i]-d[j];
  for (i=0;i<=D;++i)
   {
    d[i]=inf;
    tat[i]=-1;
    heap[i]=i;
    pos[i]=i;
   }
  heap[1]=S;//heap[S]=1;
  pos[1]=S;pos[S]=1;
  L=1;d[S]=0;
  while (L && d[heap[1]]!=inf)
   {
    for (i=1;i<=D;++i)
     {
      if (cap[heap[1]][i]>flux[heap[1]][i] && d[i]>d[heap[1]]+cost[heap[1]][i])
	{
	 d[i]=d[heap[1]]+cost[heap[1]][i];
	 tat[i]=heap[1];
	 heap[++L]=i;
	 up_heap(i);
	}
     }
    heap[1]=heap[L--];
    pos[heap[1]]=1;
//    if (L>1)
    down_heap(1);
   }
  if (d[D]!=inf)
     {
      drum=1;
      for (i=D;i!=S;i=tat[i])
       {
	flux[tat[i]][i]++;
	flux[i][tat[i]]--;
       }
      s+=d[D];
      return s;
     }
  return 0;
 }

int Flux()
 {
  drum=1;
  int rez=0;
  while (drum)
   {
    drum=0;
    rez+=dijkstra();
   }
  return rez;
 }

int main()
 {
  ifstream be ("cc.in");
  ofstream ki ("cc.out");
  int i,j;
  be>>n;
  for (i=1;i<=n;++i)
   for (j=1;j<=n;++j)
     {
      be>>cost[i][n+j];
      cost[n+j][i]=-cost[i][n+j];
      cap[i][n+j]=1;
     }
  be.close();
 /* for (i=1;i<=2*n+1;++i)
    for (j=1;j<=2*n+1;++j)
       if (cost[i][j]==0) cost[i][j]=inf,cost[j][i];*/

  S=0,D=2*n+1;
  for (i=1;i<=n;++i)
   {
    cost[n+i][D]=0;
    cap[n+i][D]=1;
    cost[S][i]=0;
    cap[S][i]=1;
   }
//  bellmanford();
  ki<<Flux()<<'\n';
  ki.close();
  return 0;
 }