#include <fstream>
#include <bitset>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

ifstream f("cc.in");
ofstream g("cc.out");

#define NMax 210
#define inf 2100000000

int n,m,S,D;
vector<int> v[NMax];
int ant[NMax];
int C[NMax][NMax],F[NMax][NMax];
int Cost[NMax][NMax];

queue<int> cd;
bitset<NMax> B;
int d[NMax];

void Bellmanford()
{
    int i,s;
    while(!cd.empty())
    {
        s=cd.front(); cd.pop();
        B[s]=0;
        for(i=0;i<(int)v[s].size();i++) if(F[s][v[s][i]]<C[s][v[s][i]]) if(d[v[s][i]]>d[s]+Cost[s][v[s][i]])
        {
            ant[v[s][i]]=s;
            d[v[s][i]]=d[s]+Cost[s][v[s][i]];
            if(!B[v[s][i]]) cd.push(v[s][i]),B[v[s][i]]=1;
        }
    }
}

int Flux()
{
    for(int i=S;i<=D;i++) d[i]=inf,ant[i]=-1;
    d[S]=0;

    cd.push(S);
    Bellmanford();

    if(d[D]==inf) return 0;

    int fmin=inf;
    int nod=D;
    while(ant[nod] != -1)
    {
        fmin=min(fmin,C[ant[nod]][nod]-F[ant[nod]][nod]);
        nod=ant[nod];
    }

    nod=D;
    while(ant[nod] != -1)
    {
        F[ant[nod]][nod]+=fmin;
        F[nod][ant[nod]]-=fmin;
        nod=ant[nod];
    }

    return fmin*d[D];
}

int main()
{
    int i,j,x;

    f>>n;

    S = 0;
    D = 2*n+1;

    for(i=1;i<=n;++i) for(j=1;j<=n;++j)
    {
        f>>x;
        v[i].push_back(n+j);
        v[n+j].push_back(i);
        C[i][n+j] = 1;
        Cost[i][n+j] = x;
        Cost[n+j][i] = -x;
    }

    for(i=1;i<=n;++i)
    {
        v[S].push_back(i);
        v[i].push_back(S);
        C[S][i] = 1;

        v[n+i].push_back(D);
        v[D].push_back(n+i);
        C[n+i][D] = 1;
    }

    int flux=0,cost=0;

    while(cost=Flux()) flux+=cost;

    g<<flux<<"\n";

    f.close();
    g.close();
    return 0;
}