#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

const int N = 214;
const int INF = 0x3f3f3f3f;

int n;
int cst[N][N];

int s, d;
int flo[N][N], cap[N][N];
vector<int> gra[N];
void read(){
	fin >> n;
	for(int a = 1; a <= n; ++a){
		for(int b = 1; b <= n; ++b){
			fin >> cst[a][b+n];
			cst[b+n][a] = -cst[a][b+n];
			
			gra[a].push_back(b+n);
			gra[b+n].push_back(a);
			
			cap[a][b+n] = 1;
		}
	}
}

void biparteeth(){
	s = 0, d = 2*n+1;
	for(int a = 1; a <= n; ++a){
		cap[s][a] = cap[a+n][d] = 1;
		gra[s].push_back(a);
		gra[a+n].push_back(d);
	}
}

queue<int> q;
bool inq[N];
int dist[N], dad[N];
void nukebell(){
	for(int a = 0; a <= 2*n+1; ++a){
		dist[a] = INF;
	}
}

bool bellman(){
	nukebell();
	dist[s] = 0;
	q.push(s);
	while(!q.empty()){
		int a = q.front();q.pop();
		inq[a] = false;
		for(auto b : gra[a]){
			int v = dist[a]+cst[a][b];
			if(v < dist[b] && flo[a][b] < cap[a][b]){
				dist[b] = v;
				dad[b] = a;
				if(!inq[b]){
					q.push(b);
				}
			}
		}
	}
	return dist[d] != INF;
}

int ans = 0;
void updateflux(){
	int fmin = INF;
	for(int a = d; a != s; a = dad[a]){
		fmin = min(fmin, cap[dad[a]][a] - flo[dad[a]][a]);
	}
	for(int a = d; a != s; a = dad[a]){
		flo[dad[a]][a] += fmin;
		flo[a][dad[a]] -= fmin;
	}
	ans += dist[d]*fmin;
}

void leflux(){
	while(bellman()){
		updateflux();
	}
}

void solve(){
	biparteeth();
	leflux();
}

int main(){
	// ios_base::sync_with_stdio(false);
	read();
	solve();
	fout << ans;
	return 0;
}