import java.util.PriorityQueue;
import java.util.Scanner;
import java.io.DataInputStream;
import java.io.InputStream;

public class MapRoute {
        private static class Parser {
                final private int BUFFER_SIZE = 1 << 16;
                private DataInputStream din;
                private byte[] buffer;
                private int bufferPointer, bytesRead;

                public Parser(InputStream in) {
                        din = new DataInputStream(in);
                        buffer = new byte[BUFFER_SIZE];
                        bufferPointer = bytesRead =  0;
                }

                public int nextInt() {
                        int rst =  0;
                        boolean negative;
                        try {
                                byte c = read();
                                while (c <= ' ')
                                        c = read();
                                negative = c == '-';
                                if (negative)
                                        c = read();
                                do {
                                        rst = rst * 10 + c - '0';
                                        c = read();
                                } while (c > ' ');

                                if (negative) return -rst;
                        } catch (Exception e) {}
                        return rst;
                }

                private void fillBuffer() {
                        try {
                                bytesRead = din.read(buffer, bufferPointer =  0, BUFFER_SIZE);
                        } catch (Exception e) {}
                        if (bytesRead == -1) buffer[ 0] = -1;
                }

                private byte read() {
                        if (bufferPointer == bytesRead) fillBuffer();
                        return buffer[bufferPointer++];
                }
        }

        public static void main(String[] args) {
        Parser in = new Parser(System.in);
        int n = in.nextInt(), i;
        int[] distances = new int[n * n];
        PriorityQueue<Vertex> priorityQueue = new PriorityQueue<>(distances.length);
        Vertex[] vertices = new Vertex[distances.length];
        for (i = 0; i < distances.length; i++) {
            distances[i] = in.nextInt();
            vertices[i] = new Vertex(i);
            priorityQueue.offer(vertices[i]);
        }
        vertices[0].key = distances[0];
        while (!priorityQueue.isEmpty()) {
            i = priorityQueue.poll().value;
            if (i / n == (i + 1) / n) {
                if (vertices[i + 1].key > vertices[i].key + distances[i + 1]) {
                    priorityQueue.remove(vertices[i + 1]);
                    vertices[i + 1].key = vertices[i].key + distances[i + 1];
                    priorityQueue.offer(vertices[i + 1]);
                }
            }
            if (i >= n) {
                if (vertices[i - n].key > vertices[i].key + distances[i - n]) {
                    priorityQueue.remove(vertices[i - n]);
                    vertices[i - n].key = vertices[i].key + distances[i - n];
                    priorityQueue.offer(vertices[i - n]);
                }
            }
            if (i > 0 && i / n == (i - 1) / n) {
                if (vertices[i - 1].key > vertices[i].key + distances[i - 1]) {
                    priorityQueue.remove(vertices[i - 1]);
                    vertices[i - 1].key = vertices[i].key + distances[i - 1];
                    priorityQueue.offer(vertices[i - 1]);
                }
            }
            if (i + n < distances.length) {
                if (vertices[i + n].key > vertices[i].key + distances[i + n]) {
                    priorityQueue.remove(vertices[i + n]);
                    vertices[i + n].key = vertices[i].key + distances[i + n];
                    priorityQueue.offer(vertices[i + n]);
                }
            }
        }
        System.out.println(vertices[distances.length - 1].key);
    }

    private static class Vertex implements Comparable<Vertex> {

        int key, value;

        Vertex(int i) {
            value = i;
            key = Integer.MAX_VALUE;
        }

        @Override
        public int compareTo(Vertex vertex) {
            return key - vertex.key;
        }

    }

}