#include <bits/stdc++.h>
#define pb push_back

using namespace std;

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

void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << H; debug_out(T...);}
#define dbg(...) cerr << #__VA_ARGS__ << " ->", debug_out(__VA_ARGS__)
#define dbg_v(x, n) do{cerr<<#x"[]: ";for(int _=0;_<n;++_)cerr<<x[_]<<" ";cerr<<'\n';}while(0)
#define dbg_ok cerr<<"OK!\n"

typedef pair<int,int> pii;
typedef long long int ll;
typedef long double ld;

const int DMAX = 210;

struct nume{
    int node,flux,cost;
};

struct nume2{
    int node,cost;
};

priority_queue <nume2> heap;

vector <int> vec;
vector <nume> arb[DMAX];

int M[DMAX][DMAX];
int Cost[DMAX][DMAX];
int dp[DMAX];
int acm[DMAX];
int dist[DMAX];
int tata[DMAX];

int n,m,start,dest;

inline bool operator<(nume2 x,nume2 y){
    return x.cost>y.cost;
}

void bellman();
bool dijkstra();

int main(){
    int t,i,j;
    int x,y,c,z;

    fin>>n;
    start=0;
    dest=2*n+1;
    for(i=1;i<=n;i++){
        M[start][i]=1;
        arb[start].pb({i,1,0});
        arb[i].pb({start,0,0});
    }
    for(i=1;i<=n;i++){
        M[n+i][dest]=1;
        arb[n+i].pb({dest,1,0});
        arb[dest].pb({n+i,0,0});
    }
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++){
            fin>>z;
            M[i][n+j]=1;
            Cost[i][n+j]=z;
            Cost[n+j][i]=-z;
            arb[i].pb({n+j,1,z});
            arb[n+j].pb({i,0,-z});
        }
    n=dest;
    bellman();
    int ans=0;
    while(dijkstra()){
        int cap=2e9;
        for(i=dest;i != start;i=tata[i])
            cap=min(cap,M[tata[i]][i]);

        for(i=dest;i != start;i=tata[i]){
            ans+=cap*Cost[tata[i]][i];
            M[tata[i]][i]-=cap;
            M[i][tata[i]]+=cap;
        }
        for(i=1;i<=n;i++)
            dp[i]=acm[i];
    }
    fout<<ans<<'\n';
    return 0;
}
void bellman(){
    for(int i=1;i<=n;i++)
        dp[i]=2e9;
    dp[start]=0;
    heap.push({start,0});
    while(!heap.empty()){
        nume2 node=heap.top();
        heap.pop();

        if(dp[node.node] != node.cost)
            continue;

        for(auto& it:arb[node.node]){
            if(it.flux && dp[it.node] > dp[node.node]+it.cost){
                dp[it.node]=dp[node.node]+it.cost;
                heap.push({it.node,dp[it.node]});
            }
        }
    }
}
bool dijkstra(){
    for(int i=1;i<=n;i++)
        dist[i]=2e9;

    dist[start]=acm[start]=0;
    heap.push({start,0});
    while(!heap.empty()){
        nume2 node=heap.top();
        heap.pop();

        if(dist[node.node] != node.cost)
            continue;

        for(auto& it:arb[node.node]){
            int cost=it.cost+dp[node.node]-dp[it.node];
            if(M[node.node][it.node] > 0 && dist[it.node] > dist[node.node]+cost){
                dist[it.node]=dist[node.node]+cost;
                acm[it.node]=acm[node.node]+it.cost;
                tata[it.node]=node.node;
                heap.push({it.node,dist[it.node]});
            }
        }
    }
    return dist[dest] != 2e9;
}