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

using namespace std;

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

const int NMAX = 100;
const int INF = 10000000;

int N, S, D;

vector <int> g[2 * NMAX + 5];

int capacity[2 * NMAX + 5][2 * NMAX + 5], flow[2 * NMAX + 5][2 * NMAX + 5];
int cost[2 * NMAX + 5][2 * NMAX + 5];

bool inq[2 * NMAX + 5];
int costTo[2 * NMAX + 5], addFlow[2 * NMAX + 5], bef[2 * NMAX + 5];

bool BellmanFord()
{
    for(int i = 0; i <= D; i++)
        costTo[i] = INF, addFlow[i] = INF;

    queue <int> Q;

    Q.push(S);
    inq[S] = true;
    costTo[S] = 0;

    while(!Q.empty())
    {
        int node = Q.front();
        Q.pop();

        inq[node] = false;

        for(auto it : g[node])
            if(capacity[node][it] > flow[node][it])
                if(costTo[it] > costTo[node] + cost[node][it])
                {
                    costTo[it] = costTo[node] + cost[node][it];
                    bef[it] = node;

                    addFlow[it] = min(addFlow[node], capacity[node][it] - flow[node][it]);

                    if(!inq[it])
                    {
                        Q.push(it);
                        inq[it] = true;
                    }
                }
    }

    return costTo[D] != INF;
}

int main()
{
    fin >> N;

    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
        {
            int x; fin >> x;

            g[i].push_back(j + N);
            g[j + N].push_back(i);

            capacity[i][j + N] = 1;

            cost[i][j + N] = x;
            cost[j + N][i] = -x;
        }

    S = 0, D = 2 * N + 1;

    for(int i = 1; i <= N; i++)
        {
            g[S].push_back(i);
            g[i].push_back(S);

            g[D].push_back(i + N);
            g[i + N].push_back(D);

            capacity[S][i] = 1;
            capacity[i + N][D] = 1;
        }

    int totalCost = 0;

    while(BellmanFord())
    {
        for(int i = D; i != S; i = bef[i])
        {
            flow[bef[i]][i] += addFlow[D];
            flow[i][bef[i]] -= addFlow[D];
        }

        totalCost += addFlow[D] * costTo[D];
    }

    fout << totalCost << '\n';

    return 0;
}