#include <bits/stdc++.h>

const int oo=1e7;

using namespace std;

ifstream f("cc.in");
ofstream g("cc.out");

int n,m,S,D,i,j,fluxmax,C[360][360],cap[360][360],dist[360];
int d[360],real_d[360],tata[360];
vector<int> v[360];

bool dijkstra()
{
    priority_queue<pair<int,int> > Q;
    for(i=1;i<=n;i++)
        d[i]=real_d[i]=oo,tata[i]=0;
    d[S]=real_d[S]=0;Q.push({0,S});
    while(Q.size())
    {
        int x=Q.top().second,
         cost=Q.top().first;
        Q.pop();
        if(d[x]!=cost)continue;
        for(auto it:v[x])
            if(cap[x][it])
            {
                int new_d=d[x]+C[x][it]+dist[it]-dist[x];
                if(new_d<d[it])
                {
                    d[it]=new_d;
                    real_d[it]=real_d[x]+C[x][it];
                    tata[it]=x;
                    Q.push({d[it],it});
                }
            }
    }
    for(i=1;i<=n;i++)
        dist[i]=real_d[i];
    if(dist[D]==oo)return 0;
//    for(i=1;i<=n;i++)
//        cout<<dist[i]<<' ';cout<<'\n';
    int x=D,flux=oo;
    while(tata[x]!=0)
    {
        flux=min(flux,cap[tata[x]][x]);
        x=tata[x];
    }
    x=D;
    //cout<<flux<<'\n';
    while(tata[x]!=0)
    {
        cap[tata[x]][x]-=flux;
        cap[x][tata[x]]+=flux;
        x=tata[x];
    }
    fluxmax+=flux*dist[D];
    return 1;
}

void bellman()
{
    queue<int> Q;
    bitset<360> in;
    for(i=1;i<=n;i++)
        dist[i]=oo,in[i]=0;
    dist[S]=0;in[S]=1;Q.push(S);
    while(Q.size())
    {
        int x=Q.front();
        Q.pop();in[x]=0;
        for(auto it:v[x])
            if(cap[x][it])
                if(dist[it]>dist[x]+C[x][it])
                {
                    dist[it]=dist[x]+C[x][it];
                    if(!in[it])
                    {
                        in[it]=1;
                        Q.push(it);
                    }
                }
    }
    return ;
}

int main()
{
    f>>n;S=1,D=2*n+2;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            int z,x=i+1,y=j+n+1;
            f>>z;
            cap[x][y]=1;
            C[x][y]=z;
            C[y][x]=-z;
            v[x].push_back(y);
            v[y].push_back(x);
        }
    }
    for(i=1;i<=n;i++)
    {
        int x=1,y=i+1;
        cap[x][y]=1;
        C[x][y]=0;
        C[y][x]=0;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    for(i=n+2;i<=2*n+1;i++)
    {
        int x=i,y=2*n+2;
        cap[x][y]=1;
        C[x][y]=0;
        C[y][x]=0;
        v[x].push_back(y);
        v[y].push_back(x);
    }
//    for(i=1;i<=2*n+2;i++)
//    {
//        for(j=1;j<=2*n+2;j++)
//            cout<<cap[i][j]<<' ';
//        cout<<'\n';
//    }cout<<'\n';
//    for(i=1;i<=2*n+2;i++)
//    {
//        for(j=1;j<=2*n+2;j++)
//            cout<<C[i][j]<<' ';
//        cout<<'\n';
//    }cout<<'\n';
    n=2*n+2;
    bellman();
//    for(i=1;i<=n;i++)
//        cout<<dist[i]<<' ';
//    for(i=1;i<=n;i++)
//        cout<<dist[i]<<' ';cout<<'\n';
    for(;dijkstra(););
    g<<fluxmax;
    return 0;
}