#include <bits/stdc++.h>

using namespace std;

constexpr int ms = 113;
constexpr int inf = 0x3f3f3f3f; // constante pra infinito..
int mat[ms][ms];
int calc[ms][ms];
int n;

// Checando se uma posicao ainda esta dentro da matriz
bool valid(int x, int y) { return ( x >= 0 && x < n && y >= 0 && y < n ); }

// Direcoes em que os movimentos estao definidos
vector< pair<int, int> > dirs = { {0, 1}, {0, -1}, {1, 0}, {-1,0} };


void dijkstra()
{
    // vamos comecar inserindo o (0, 0)
    set< tuple<int, int, int> > prioridade;

    prioridade.emplace(0, 0, 0);
    // sintaxe alternativa prioridade.push_back( make_tuple(0, 0, 0 ) );
    calc[0][0] = 0;

    while( !prioridade.empty() )
    {
        // Capturando Elemento de menor distancia
        auto topo = *(prioridade.begin() );

        // Apagando esse elemento da fila de prioridade
        prioridade.erase( prioridade.begin() );

        int cur_dist = get<0>( topo );
        int cur_x = get<1>( topo );
        int cur_y = get<2>( topo );

        // Aqui estou fazendo um loop pelo vetor de direcoes
        for(const auto& dir : dirs )
        {
            int novo_x = cur_x + dir.first;
            int novo_y = cur_y + dir.second;
            // Vamos checar se nao saimos do grid

            if( valid(novo_x, novo_y) == true )
            {
                // Aqui vou checar de estou 'descobrindo' uma celula com um custo menor do que ela ja tinha sido descoberta
                if( cur_dist + (mat[novo_x][novo_y] ) < calc[novo_x][novo_y] )
                {
                    // Se o custo dela for != inf, significa que alguem achou um caminho ate (novo_x, novo_y),
                    // Esse caminho foi inserido no nosso set, mas ele é ótimo
                    // Então temos que remover a tupla ( distancia_nao_otima[ novo_x ][ novo_y ], novo_x, novo_y ) do set
                    // Atualizar a distancia de [novo_x][novo_y] e inserir a tupla atualizada no nosso set..
                    // É exatamente o que o código abaixo faz
                    if( calc[novo_x][novo_y] != inf )
                    {
                        prioridade.erase( make_tuple(calc[novo_x][novo_y], novo_x, novo_y ) );
                    }
                    calc[novo_x][novo_y] = cur_dist + ( mat[novo_x][novo_y] );
                    prioridade.emplace( calc[novo_x][novo_y], novo_x, novo_y );
                }
            }
        }
    }
}



int main()
{
    ios::sync_with_stdio( false ); cin.tie( nullptr );
    cin >> n;
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < n; ++j)
        {
            cin >> mat[i][j];
            calc[i][j] = inf; // inicializando valores
        }
    }
    dijkstra();
    cout << calc[n - 1][n - 1] << endl;
}