#include <fstream>
#include <cstring>
#include <queue>

using namespace std;

#define INF 1e9

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

const int MAX_N = 101;

int n, nod, destinatie, flux, predecesor[MAX_N], dist[MAX_N], G[MAX_N][MAX_N], cost[MAX_N][MAX_N];
bool viz[MAX_N];

bool bellmanFord()
{
    memset(viz, 0, sizeof(viz));
    memset(dist, INF, sizeof(dist));

    dist[nod] = 0;
    viz[nod] = true;

    queue<int> q;
    q.push(nod);

    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        viz[x] = false;

        for (int i = 1; i <= destinatie; i++)
        {
            if (G[x][i] && dist[i] > dist[x] + cost[x][i])
            {
                dist[i] = dist[x] + cost[x][i];
                predecesor[i] = x;

                if (!viz[i])
                {
                    viz[i] = true;
                    q.push(i);
                }
            }
        }
    }

    return dist[destinatie] != INF;
}

int main()
{
    f >> n;

    nod = 0;
    destinatie = 2 * n + 1;

    for (int i = 1; i <= n; i++)
    {
        G[nod][i] = 1;
        G[i][nod] = 0;
        G[n + i][destinatie] = 1;
        G[destinatie][n + i] = 0;
    }

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            f >> cost[i][n + j];
            cost[n + j][i] = -cost[i][n + j];
            G[i][n + j] = 1;
            G[n + j][i] = 0;
        }

    flux = 0;

    while (bellmanFord())
    {
        for (int i = destinatie; i != nod; i = predecesor[i])
        {
            G[predecesor[i]][i]--;
            G[i][predecesor[i]]++;
        }
        flux += dist[destinatie];
    }

    g << flux << '\n';

    return 0;
}