#include <cstdio>
#include <queue>
#include <vector>
#include <algorithm>
#include <bitset>

#define DIM 1256
#define INF 1000000000
using namespace std;

int nrNodes, startNode, finishNode, flow;

int Distance[DIM], Capacity[DIM][DIM];
int Cost[DIM][DIM], MaxFlow[DIM][DIM];
bitset <DIM> Marked; queue <int> Queue;
vector <int> Edges[DIM]; int Father[DIM];
pair <int , int> SolEdges[DIM*100]; int cost;

bool bellmanFord (int startNode, int finishNode)
{
    while (!Queue.empty()) Queue.pop();
    Marked.reset(); Marked[startNode] = 1;
    Queue.push(startNode);

    for (int i = 0; i <= finishNode; i ++)
        Distance[i] = INF;
    Distance[startNode] = 0;

    int ok = 0;
    while (!Queue.empty())
    {
        int node = Queue.front();

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (MaxFlow[node][nextNode] < Capacity[node][nextNode])
            if (Distance[nextNode] > Distance[node] + Cost[node][nextNode])
            {
                Distance[nextNode] = Distance[node] + Cost[node][nextNode];
                Father[nextNode] = node;

                if (!Marked[nextNode])
                {
                    Marked[nextNode] = 1;
                    Queue.push(nextNode);

                    if (nextNode == finishNode)
                        ok = 1;
                }
            }
        }

        Marked[node] = 0;
        Queue.pop();
    }

    return ok;
}

int main ()
{
    freopen ("cc.in" ,"r", stdin );
    freopen ("cc.out","w", stdout);

    scanf ("%d", &nrNodes);
    startNode = 0; finishNode = 2 * nrNodes + 1;

    for (int i = startNode + 1; i <=  nrNodes   - 0; i ++)
    for (int j =  nrNodes  + 1; j <= finishNode - 1; j ++)
    {
        scanf ("%d", &cost);

        Capacity[i][j] = 1; Cost[i][j] =  cost;
        Capacity[j][i] = 0; Cost[j][i] = -cost;

        Edges[i].push_back(j);
        Edges[j].push_back(i);
    }

    for (int i = 1; i <= nrNodes; i ++)
    {
        Capacity[startNode][i] = 1;
        Capacity[i][startNode] = 0;

        Edges[startNode].push_back(i);
        Edges[i].push_back(startNode);
    }

    for (int i = nrNodes + 1; i <= finishNode - 1; i ++)
    {
        Capacity[i][finishNode] = 1;
        Capacity[finishNode][i] = 0;

        Edges[i].push_back(finishNode);
        Edges[finishNode].push_back(i);
    }

    flow = 0, cost = 0;
    while (bellmanFord(startNode, finishNode))
    {
        int minim = INF;

        for (int node = finishNode; node != startNode; node = Father[node])
            minim = min (minim, Capacity[Father[node]][node] - MaxFlow[Father[node]][node]);

        flow += minim;

        for (int node = finishNode; node != startNode; node = Father[node])
        {
            MaxFlow[Father[node]][node] += minim;
            MaxFlow[node][Father[node]] -= minim;

            cost += minim * Cost[Father[node]][node];
        }
    }

    printf ("%d\n", cost);

    fclose (stdin );
    fclose (stdout);

    return 0;
}