#include <fstream>
#include <iostream>
#include <limits>
#include <queue>
using namespace std;

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

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

int nodes, capacities[201][201], flows[201][201], predecessors[201], distances[201], totalCost = 0;

bool ford()
{
    fill(distances, distances + 201, INF);
    distances[0] = 0;
    predecessors[0] = -1;

    for (int iteration = 0; iteration < nodes + nodes + 1; iteration++)
    {
        for (int from = 0; from <= nodes + nodes + 1; from++)
        {
            for (int to = 0; to <= nodes + nodes + 1; to++)
            {
                if (flows[from][to] < capacities[from][to] && distances[to] > distances[from] + capacities[from][to])
                {
                    distances[to] = distances[from] + capacities[from][to];
                    predecessors[to] = from;
                }
            }
        }
    }

    return distances[nodes + 1] < INF;
}

void flow(int vertex, int minEdge)
{
    if (vertex == 0)
        return;

    int previousVertex = predecessors[vertex];
    flows[previousVertex][vertex] += minEdge;
    flows[vertex][previousVertex] -= minEdge;
    flow(previousVertex, minEdge);
}

int main()
{
    fin >> nodes;

    for (int i = 1; i <= nodes; i++)
    {
        for (int j = 1; j <= nodes; j++)
        {
            fin >> capacities[i][nodes + j + 1];
            capacities[nodes + j + 1][i] = -capacities[i][nodes + j + 1];
            capacities[0][i] = capacities[i + nodes + 1][nodes + 1] = 1;
        }
    }

    while (ford())
    {
        int minEdge = INF;
        for (int vertex = nodes + 1; vertex != 0; vertex = predecessors[vertex])
        {
            int previousVertex = predecessors[vertex];
            minEdge = min(minEdge, capacities[previousVertex][vertex] - flows[previousVertex][vertex]);
        }

        flow(nodes + 1, minEdge);
        totalCost += distances[nodes + 1] * minEdge;
    }

    fout << totalCost;

    return 0;
}