#include <bits/stdc++.h>
using namespace std;

int n, m, S, D;
int Fc;
int d[205], C[205][205], Cost[205][205], reald[205], old[205], TT[205];
bool f[205];
vector <int> v[205];
priority_queue <pair <int, int> > pq;
queue <int> q;
inline void bellman(){
    for(int i = 0; i <= n ; ++i)
        old[i] = 2000000000;
    q.push(S);
    old[S] = 0;
    while(!q.empty()){
        int nod = q.front();
        q.pop();
        f[nod] = 0;
        for(auto it : v[nod]){
            if(!C[nod][it]) continue ;
            if(old[it] > old[nod] + Cost[nod][it]){
                old[it] = old[nod] + Cost[nod][it];
                if(f[it] == 0)  f[it] = 1, q.push(it);
            }
        }
    }
}
inline bool dijkstra(){
    for(int i = 0; i <= n ; ++i)
        d[i] = 2000000000;
    d[S] = 0; reald[S] = 0;
    pq.push({0, S});

    while(!pq.empty()){
        int nod = pq.top().second;
        pq.pop();
        for(auto it : v[nod]){
            if(!C[nod][it]) continue ;
            if(d[it] > d[nod] + Cost[nod][it] + old[nod] - old[it]){
                d[it] = d[nod] + Cost[nod][it] + old[nod] - old[it];
                reald[it] = reald[nod] + Cost[nod][it];
                pq.push({-d[it], it});
                TT[it] = nod;
            }
        }
    }

    memcpy(old, reald, sizeof(old));
    if(d[D] == 2000000000) return false;

    int Minf = 2000000000, cst = 0;
    for(int w = D; w != S ; w = TT[w]){
        Minf = min(Minf, C[TT[w]][w]);
        cst += Cost[TT[w]][w];
    }

    Fc += Minf * reald[D];

    for(int w = D; w != S ; w = TT[w]){
        C[TT[w]][w] -= Minf;
        C[w][TT[w]] += Minf;
    }
    return true;
}
int main()
{
    freopen("cc.in", "r", stdin);
    freopen("cc.out", "w", stdout);

    scanf("%d", &n);
    int c;
    for(int i = 1; i <= n ; ++i){
        for(int j = 1; j <= n ; ++j){
            scanf("%d", &c);
            v[i].push_back(j + n);
            v[j + n].push_back(i);
            C[i][j + n] = 1;
            Cost[i][j + n] = c;
            Cost[j + n][i] = -c;
        }

    }
    for(int i = 1; i <= n ; ++i){
        v[0].push_back(i);
        v[i].push_back(0);
        C[0][i] = 1;
    }
    for(int i = n + 1; i <= 2 * n ; ++i){
        v[2 * n + 1].push_back(i);
        v[i].push_back(2 * n + 1);
        C[i][2 * n + 1] = 1;
    }

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

    bellman();
    while(dijkstra()) ;
    printf("%d", Fc);
    return 0;
}