#pragma clang diagnostic push
#pragma ide diagnostic ignored "cppcoreguidelines-interfaces-global-init"

#include <climits>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int distante[300][300], capacitati[300][300], parinti[300], distante_bf[300];
vector<int> graf[300];

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

bool bellman_ford(int start, int end, int muchii) {
    fill(distante_bf, distante_bf + muchii, 1000000000);
    fill(parinti, parinti + 100, -1);

    queue<int> q;
    distante_bf[start] = 0;
    q.push(start);

    while (!q.empty()) {
        int curr = q.front();
        q.pop();

        for (int adj : graf[curr]) {
            if (capacitati[curr][adj] > 0 && distante_bf[adj] > distante_bf[curr] + distante[curr][adj]) {
                distante_bf[adj] = distante_bf[curr] + distante[curr][adj];
                parinti[adj] = curr;
                q.push(adj);
            }
        }
    }

    return distante_bf[end] != 1000000000;
}

int min_cost_max_flow(int start, int end, int muchii) {
    int flux = 0, cost = 0;

    while (bellman_ford(start, end, muchii)) {
        int pathFlow = INT_MAX;
        for (int vertex = end; vertex != start; vertex = parinti[vertex]) {
            int parinte = parinti[vertex];
            pathFlow = min(pathFlow, capacitati[parinte][vertex]);
        }

        for (int vertex = end; vertex != start; vertex = parinti[vertex]) {
            int parentVertex = parinti[vertex];
            capacitati[parentVertex][vertex] -= pathFlow;
            capacitati[vertex][parentVertex] += pathFlow;
            cost += pathFlow * distante[parentVertex][vertex];
        }

        flux += pathFlow;
    }

    return cost;
}

int main() {
    int size;
    fin >> size;

    int start = 0, end = 2 * size + 1;
    for (int i = 1; i <= size; i++) {
        graf[start].push_back(i);
        capacitati[start][i] = 1;

        graf[i + size].push_back(end);
        capacitati[i + size][end] = 1;

        for (int j = 1; j <= size; j++) {
            fin >> distante[i][j + size];
            distante[j + size][i] = -distante[i][j + size];
            graf[i].push_back(j + size);
            graf[j + size].push_back(i);
            capacitati[i][j + size] = 1;
        }
    }

    fout << min_cost_max_flow(start, end, 2 * size + 2) << endl;

    return 0;
}

#pragma clang diagnostic pop