#include <cstdio>
#include <queue>

using namespace std;

struct edge
{
    int nod,c;
    bool operator <(const edge aux) const
    {
        return c>aux.c;
    }
};

const int inf=1e9;
queue<int> q1;
priority_queue<edge> q;
vector<pair<int,int>> v[210];
int sursa,dest,dist[210],vaz[210],d[210],dist1[210],cap_flow[210][210],tata[210];

void Bellman_ford()
{
    for(int i=sursa;i<=dest;i++) dist[i]=inf;
    dist[sursa]=0;
    vaz[sursa]=1;
    q1.push(sursa);
    while(!q1.empty())
    {
        int nod=q1.front();
        q1.pop();
        vaz[nod]=0;
        for(int i=0;i<v[nod].size();i++)
        {
            int vec=v[nod][i].first,c=v[nod][i].second;
            if(cap_flow[nod][vec]>0 && dist[nod]+c<dist[vec])
            {
                dist[vec]=dist[nod]+c;
                if(vec!=dest && vaz[vec]==0) {vaz[vec]=1;q1.push(vec);}
            }
        }
    }
}

int dijkstra()
{
    for(int i=sursa;i<=dest;i++) d[i]=dist1[i]=inf;
    d[sursa]=dist1[sursa]=0;
    q.push({sursa,0});
    while(!q.empty())
    {
        int nod=q.top().nod,c=q.top().c;
        q.pop();
        if(c>d[nod]) continue;
        for(int i=0;i<v[nod].size();i++)
        {
            int vec=v[nod][i].first,cost=v[nod][i].second;
            if(cap_flow[nod][vec]>0 && d[nod]+dist[nod]+cost-dist[vec]<d[vec])
            {
                d[vec]=d[nod]+dist[nod]+cost-dist[vec];
                dist1[vec]=dist1[nod]+cost;
                tata[vec]=nod;
                if(vec!=dest) q.push({vec,d[vec]});
            }
        }
    }
    for(int i=sursa;i<=dest;i++) dist[i]=dist1[i];
    return d[dest]<inf;
}

int main()
{
    freopen("cc.in","r",stdin);
    freopen("cc.out","w",stdout);
    int n,c;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&c);
            cap_flow[i][n+j]=1;
            v[i].push_back({n+j,c});
            v[n+j].push_back({i,-c});
        }
    sursa=0,dest=2*n+1;
    for(int i=1;i<=n;i++)
    {
        cap_flow[sursa][i]=1;
        cap_flow[i+n][dest]=1;
        v[sursa].push_back({i,0});
        v[i].push_back({sursa,0});
        v[i+n].push_back({dest,0});
        v[dest].push_back({i+n,0});
    }
    Bellman_ford();
    int sol=0;
    while(dijkstra())
    {
        int s=inf;
        for(int nod=dest;nod!=sursa;nod=tata[nod]) s=min(s,cap_flow[tata[nod]][nod]);
        for(int nod=dest;nod!=sursa;nod=tata[nod])
        {
            cap_flow[tata[nod]][nod]-=s;
            cap_flow[nod][tata[nod]]+=s;
        }
        sol+=s*dist[dest];
    }
    printf("%d",sol);
    return 0;
}