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

using namespace std;

const char InFile[]="cc.in";
const char OutFile[]="cc.out";
const int MaxN=105;
const int MaxNodes=2*MaxN;
const int INF=1<<30;

ifstream fin(InFile);
ofstream fout(OutFile);

int N,S,D,x,C[MaxNodes][MaxNodes],F[MaxNodes][MaxNodes],Cost[MaxNodes][MaxNodes];
bool ok;
vector<int> G[MaxNodes];
queue<int> Q;
char inQ[MaxNodes];
int Dist[MaxNodes],From[MaxNodes];

inline int BellmanFord()
{
	ok=false;
	for(register int i=0;i<=D;++i)
	{
		From[i]=0;
		Dist[i]=INF;
	}

	Dist[S]=0;
	Q.push(S);
	inQ[S]=1;
	while(!Q.empty())
	{
		int nod=Q.front();
		Q.pop();
		inQ[nod]=0;

		for(vector<int>::iterator it=G[nod].begin();it!=G[nod].end();++it)
		{
			if(C[nod][*it]-F[nod][*it]>0)
			{
				if(Dist[*it]>Dist[nod]+Cost[nod][*it])
				{
					Dist[*it]=Dist[nod]+Cost[nod][*it];
					From[*it]=nod;
					if(!inQ[*it])
					{
						inQ[*it]=1;
						Q.push(*it);
					}
				}
			}
		}
	}

	if(Dist[D]!=INF)
	{
		ok=true;
		int minim=INF;
		int t=D;
		for(;t!=S;t=From[t])
		{
			if(minim>C[From[t]][t]-F[From[t]][t])
			{
				minim=C[From[t]][t]-F[From[t]][t];
			}
		}
		t=D;
		for(;t!=S;t=From[t])
		{
			F[From[t]][t]+=minim;
			F[t][From[t]]-=minim;
		}
		return Dist[D]*minim;
	}

	return 0;
}

inline int MinCostMaxFlow()
{
	int sol=0;
	ok=true;
	while(ok)
	{
		sol+=BellmanFord();
	}
	return sol;
}

inline void Connect(int from, int to, int cost)
{
	G[from].push_back(to);
	G[to].push_back(from);
	C[from][to]=1;
	Cost[from][to]=cost;
	Cost[to][from]=-cost;
}

int main()
{
	fin>>N;
	S=2*(N+1);
	D=S+1;
	for(register int i=1;i<=N;++i)
	{
		Connect(S,(i<<1),0);
		Connect((i<<1)+1,D,0);
		for(register int j=1;j<=N;++j)
		{
			fin>>x;
			Connect(i<<1,(j<<1)+1,x);
		}
	}
	fin.close();

	fout<<MinCostMaxFlow();
	fout.close();
	return 0;
}