#include <bits/stdc++.h>
using namespace std;
ifstream fin("cc.in");
ofstream fout("cc.out");
//pb9:https://www.infoarena.ro/problema/cc

class Graf {
    int nr_noduri;
    vector<vector<int>> capacitati;
    vector<vector<int>> costuri;
    vector<vector<int>> flux;

public:
    Graf(int n) : nr_noduri(n) {
        capacitati.resize(nr_noduri, vector<int>(nr_noduri, 0));
        costuri.resize(nr_noduri, vector<int>(nr_noduri, 0));
        flux.resize(nr_noduri, vector<int>(nr_noduri, 0));

    }

    void adauga_capacitate(int x, int y, int capacitate, int cost) {
        capacitati[x][y] = capacitate;
        capacitati[y][x] = 0;
        costuri[x][y] = cost;
        costuri[y][x] = -cost;
    }
    bool dijkstra(int sursa, int destinatie,vector<int>& tati) {
        vector<int> dst(nr_noduri, static_cast<int>(1e18));
        dst[sursa] = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
        pq.emplace(0, sursa);

        while (!pq.empty()) {
            int nod = pq.top().second;
            int dst_N = pq.top().first;
            pq.pop();

            if (dst_N > dst[nod]) {
                continue;
            }

            for (int v = 0; v < nr_noduri; v++) {
                if (capacitati[nod][v] - flux[nod][v] > 0 &&
                    dst[nod] != static_cast<int>(1e18) &&
                    dst[nod] + costuri[nod][v] < dst[v]) {
                    dst[v] = dst[nod] + costuri[nod][v];
                    tati[v] = nod;
                    pq.emplace(dst[v], v);
                }
            }
        }

        return dst[destinatie] != static_cast<int>(1e18);
    }

    int flux_maxim(int sursa, int destinatie) {
        int fluxMaxim = 0;
        vector<int> parent(nr_noduri, -1);

        while (dijkstra(sursa, destinatie, parent)) {
            int fluxMinim = static_cast<int>(1e18);
            int nod = destinatie;

            while (nod != sursa) {
                fluxMinim = min(fluxMinim, capacitati[parent[nod]][nod] - flux[parent[nod]][nod]);
                nod = parent[nod];
            }

            fluxMaxim += fluxMinim;
            nod = destinatie;

            while (nod != sursa) {
                flux[parent[nod]][nod] += fluxMinim;
                flux[nod][parent[nod]] -= fluxMinim;
                nod = parent[nod];
            }
        }

        return fluxMaxim;
    }

    int cost_mini() const {
        int c_mini = 0;

        for (int i = 0; i < nr_noduri; i++) {
            for (int j = 0; j < nr_noduri; j++) {
                c_mini += flux[i][j] * costuri[i][j];
            }
        }

        return c_mini;
    }
};

int main() {


    int N;

    fin >> N;
    int sursa = 2 * N;
    int destinatie = 2 * N + 1;
    Graf g(destinatie+1);

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            int d;
            fin >> d;
            g.adauga_capacitate(i, j + N, 1, d);
        }
    }
    fin.close();



    for (int i = 0; i < N; ++i) {
        g.adauga_capacitate(sursa, i, 1, 0);
    }

    for (int j = 0; j < N; ++j) {
        g.adauga_capacitate(j + N, destinatie, 1, 0);
    }

    g.flux_maxim(sursa, destinatie);
    int mini = g.cost_mini();
    mini /= 2;

    fout << mini << '\n';
    fout.close();

    return 0;
}