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

using namespace std;

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

const int N = 105 * 2;
const int INF = 1e9;

int n, fmax, costMin;
int t[N], cap[N][N], cost[N][N], flow[N][N];
vector<int> positiveDist;
vector<int> g[N];
vector<bool> vis;

void Dijkstra(int startNode)
{
    positiveDist.assign(2 * n + 2, INF);
    vis.assign(2 * n + 2, false);

    priority_queue<pair<int, int>> heap;

    heap.push({0, startNode});

    while(!heap.empty())
    {
        int x = heap.top().second;
        int distx = -heap.top().first;
        heap.pop();

        if(vis[x])
            continue;
        vis[x] = true;
        
        for(int y : g[x])
        {
            if(!vis[y] && flow[x][y] != cap[x][y] && distx + cost[x][y] < positiveDist[y])
            {
                positiveDist[y] = distx + cost[x][y];
                heap.push({ -positiveDist[y], y });
                t[y] = x;
            }
        }
    }
}

void maxFlowMinCost(int source, int sink)
{
    // BellmanFordCoada(source);
    do
    {
        Dijkstra(source);

        if(positiveDist[sink] == INF)
            break;

        int fmin = 1 << 30;
        for(int node = sink; node != source; node = t[node])
            fmin = min(fmin, cap[t[node]][node] - flow[t[node]][node]);

        fmax += fmin;
        costMin += positiveDist[sink] * fmin;
        for(int node = sink; node != source; node = t[node])
        {
            flow[t[node]][node] += fmin;
            flow[node][t[node]] -= fmin;
        }
    } while(positiveDist[sink] != INF);
}

void addEdge(int x, int y, int c, int z)
{
    g[x].push_back(y);
    g[y].push_back(x);
    cap[x][y] = c;
    cap[y][x] = 0;
    cost[x][y] = z;
    cost[y][x] = -z;
}

int main()
{
    fin >> n;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            int c;
            fin >> c;
            addEdge(i, n + j, 1, c);
        }
    }
    
    for (int i = 1; i <= n; i++)
    {
        addEdge(0, i, 1, 0);
        addEdge(n + i, 2 * n + 1, 1, 0);
    }

    maxFlowMinCost(0, 2 * n + 1);
    fout << costMin << '\n';

    return 0;
}