// https://www.infoarena.ro/problema/cc

#include <iostream>
#include <vector>
#include <utility>
#include <climits>
#include <deque>
#include <queue>
#include <fstream>
#include <algorithm>

using namespace std;


class Graph
{
private:
    static const int MAX_VERTICES = 1000;
    static const int MAX_EDGES = 5000;

    int noVertices;
    int noEdges;

    vector<vector<int>> neighbours;
    vector<vector<int>> capacity;
    vector<vector<int>> flow;
    vector<vector<int>> distance;

public:
    Graph(const int &noVertices)
        : noVertices(noVertices),
          neighbours(noVertices + 1),
          capacity(noVertices + 1, vector<int>(noVertices + 1, 0)),
          flow(noVertices + 1, vector<int>(noVertices + 1, 0)),
          distance(noVertices + 1, vector<int>(noVertices + 1, 0))
    {
    }

    int getNoVertices()
    {
        return noVertices;
    }

    int getNoEdges()
    {
        return noEdges;
    }


    void addNeighbour(const int& vertex, const int& neighbour_to_add, const int& capacity, const int& distance = 0)
    {
        neighbours[vertex].push_back(neighbour_to_add);
        neighbours[neighbour_to_add].push_back(vertex);

        this->capacity[vertex][neighbour_to_add] = capacity;

        this->distance[vertex][neighbour_to_add] = distance;
        this->distance[neighbour_to_add][vertex] = -distance;
    }


    bool BFS(const int& source, const int& sink, vector<int>& parent, vector<int>& minDistance)
    {
        parent = vector<int> (noVertices + 1, -2);
        minDistance = vector<int> (noVertices + 1, INT_MAX);
         

        queue<int> que;

        que.push(source);
        minDistance[source] = 0;

        parent[source] = -1;

        while (!que.empty())
        {
            int curr_vertex = que.front();
            que.pop();

            for (int neigh : neighbours[curr_vertex])
            {
                //atunci cand avem muchia inversa, capacitatea este 0
                //deci cand flow-ul este 0, nu putem "intoarce" pe acolo ceva
                //cand flow-ul este diferit de 0 (adica negativ) putem intoarce pe acolo ceva
                if (flow[curr_vertex][neigh] == capacity[curr_vertex][neigh]
                || minDistance[curr_vertex] + distance[curr_vertex][neigh] >= minDistance[neigh])
                    continue;

                parent[neigh] = curr_vertex;
                minDistance[neigh] = minDistance[curr_vertex] + distance[curr_vertex][neigh];
                que.push(neigh);

            }
        }

        return parent[sink] != -2;

    }

    int getMaxFlow()
    {
        const int source = 0;
        const int sink = noVertices;

        int maxFlow = 0;
        int result = 0;
        vector<int> parent;
        vector<int> minDistance;

        while(BFS(source, sink, parent, minDistance))
        {
            int minFlowPath = INT_MAX;

            int curr_vertex = sink;
            int curr_parent = parent[sink];

            //de remarcat ca atunci cand avem o muchie de intoarcere, diferenta o sa fie 
            //0 - (un flux negativ), deci o sa comparam in continuare cu un numar pozitiv
            for ( ; curr_vertex != source; curr_vertex = curr_parent, curr_parent = parent[curr_vertex])
                if (capacity[curr_parent][curr_vertex] - flow[curr_parent][curr_vertex] < minFlowPath)
                    minFlowPath = capacity[curr_parent][curr_vertex] - flow[curr_parent][curr_vertex];
            
            maxFlow += minFlowPath;

            curr_vertex = sink;
            curr_parent = parent[sink];
            for ( ; curr_vertex != source; curr_vertex = curr_parent, curr_parent = parent[curr_vertex])
            {
                flow[curr_parent][curr_vertex] += minFlowPath;
                flow[curr_vertex][curr_parent] -= minFlowPath;
            }


            result += minDistance[noVertices];
        }

        return result;
    }


};



int main()
{
    int N;

    ifstream fin ("cc.in");
    fin >> N;
    Graph graph(2 * N + 1);

    for (int i=1; i<=N; i++)
    {
        graph.addNeighbour(0, i, 1);
        graph.addNeighbour(i + N, 2 * N + 1, 1);

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

            graph.addNeighbour(i, j + N, 1, dist);
        }
    }
    
    fin.close();

    ofstream fout("cc.out");
    fout << graph.getMaxFlow() << "\n";

    fout.close();

    return 0;
}