#include <iostream>
#include <vector>
#include <fstream>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max();

int hungarianAlgorithm(vector<vector<int>>& cost) {
    int n = cost.size();
    vector<int> u(n+1), v(n+1), p(n+1), way(n+1);
    for (int i = 1; i <= n; ++i) {
        p[0] = i;
        int j0 = 0;
        vector<int> minv(n+1, INF);
        vector<char> used(n+1, false);
        do {
            used[j0] = true;
            int i0 = p[j0], delta = INF, j1;
            for (int j = 1; j <= n; ++j)
                if (!used[j]) {
                    int cur = cost[i0-1][j-1] - u[i0] - v[j];
                    if (cur < minv[j])
                        minv[j] = cur, way[j] = j0;
                    if (minv[j] < delta)
                        delta = minv[j], j1 = j;
                }
            for (int j = 0; j <= n; ++j)
                if (used[j])
                    u[p[j]] += delta, v[j] -= delta;
                else
                    minv[j] -= delta;
            j0 = j1;
        } while (p[j0] != 0);
        for (int j1; j0; j0 = j1)
            j1 = way[j0], p[j0] = p[j1];
    }
    return -v[0];
}

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

    int N;
    f >> N;
    vector<vector<int>> costMatrix(N, vector<int>(N));

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            f >> costMatrix[i][j];
        }
    }

    int result = hungarianAlgorithm(costMatrix);
    g << result << endl;

    f.close();
    g.close();
    return 0;
}