#include<fstream>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

ifstream fin("cc.in");
ofstream fout("cc.out");


#define NMAX 203
#define INF 1<<30
int N;

int D; int S;int From[NMAX];int dist[NMAX];

vector<int> G[NMAX];

int C[NMAX][NMAX]; int F[NMAX][NMAX]; int Cost[NMAX][NMAX];int drum;

bool s[NMAX];

void Read() {

    fin >>N;
    D = 2 * N + 1;
    S = 0;
    for(int i = 1; i <= N; ++i){
        G[0].push_back(i);
        G[i].push_back(0);
        C[0][i] = 1;
        G[D].push_back(N + i);
        G[N + i].push_back(D);
        C[i + N][D] = 1;
        for(int j = N + 1; j <= 2 * N; ++j){
            int x;
            fin >>x ;
            G[i].push_back(j);
            G[j].push_back(i);
            C[i][j] = 1;
            Cost[i][j] = x;
            Cost[j][i] = -x;
        }
    }
}

int BellmanFord(){

    memset(s, 0, sizeof(s));
    s[0] = true;
    queue<int> q;
    q.push(0);
    for(int i = 0; i <= D; ++i) dist[i] = INF;
    dist[0] = 0 ;
    while(!q.empty()){
        int nod = q.front();
        q.pop();
        for(int i = 0 ;i < G[nod].size(); ++i){
            int x = G[nod][i];
            if(C[nod][x] - F[nod][x] >0 && dist[nod] + Cost[nod][x] < dist[x]){
                dist[x] = dist[nod] + Cost[nod][x];
                From[x] = nod;
                if(s[x] == false)
                    s[x] = true, q.push(x);
            }
        }
        s[nod] = false;
    }

    if(dist[D] != INF){

        int vmin = INF;
        drum = 1;
        for(int i = D; i != S; i = From[i])
            vmin = min(vmin , C[From[i]][i] - F[From[i]][i] );

        for(int i = D; i != S; i = From[i])
            F[From[i]][i] += vmin, F[i][From[i]] -= vmin;
        return vmin * dist[D];//vmin = 1

    }
    return 0;
}

void Solve(){

    drum = 1;
    int rez = 0;

    while(drum){
        drum = 0;
        rez += BellmanFord();
    }

    fout << rez;

}


int main(){

    Read ();

    Solve ();

    return 0;

}