use std::io;
use std::str::FromStr;

fn input<T:FromStr>() -> T {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().parse().ok().unwrap()
}

fn input_vec() -> Vec<u64> {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.split_whitespace().map(|s| s.parse().unwrap()).collect()
}
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::usize;

#[derive(Copy, Clone, Eq, PartialEq)]
struct State {
    cost: usize,
    position: usize,
}

impl Ord for State {
    fn cmp(&self, other: &State) -> Ordering {
        other.cost.cmp(&self.cost)
            .then_with(|| self.position.cmp(&other.position))
    }
}

impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

#[derive(Clone)]
struct Edge {
    node: usize,
    cost: usize,
}

// Dijkstra's shortest path algorithm.
fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize) -> Vec<usize> {
    // dist[node] = current shortest distance from `start` to `node`
    let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();

    let mut heap = BinaryHeap::new();

    dist[start] = 0;
    heap.push(State { cost: 0, position: start });

    while let Some(State { cost, position }) = heap.pop() {
        if cost > dist[position] { continue; }

        for edge in &adj_list[position] {
            let next = State { cost: cost + edge.cost, position: edge.node };
            if next.cost < dist[next.position] {
                heap.push(next);
                dist[next.position] = next.cost;
            }
        }
    }
    dist
}

fn idx(y: usize, x: usize, w: usize) -> usize {
    y * w + x
}

fn main() {
    let n: usize = input();
    let p_vec = input_vec();
    
    let mut grid: Vec<usize> = Vec::new();
    grid.append(&mut vec![0; n + 2]);
    for i in 0..n {
        grid.push(0);
        grid.append(&mut vec![1; n]);
        grid.push(0);
    }
    grid.append(&mut vec![0; n + 2]);
    // println!("{:?}", grid);

    let mut edges: Vec<Vec<Edge>> = vec![Vec::new(); (n + 2) * (n + 2)];
    for col_i in 1..(n+1) {
        for row_i in 1..(n+1) {
            edges[idx(col_i, row_i, n + 2)].push(Edge {node: idx(col_i, row_i + 1, n + 2), cost: grid[idx(col_i, row_i + 1, n + 2)]});
            edges[idx(col_i, row_i, n + 2)].push(Edge {node: idx(col_i, row_i - 1, n + 2), cost: grid[idx(col_i, row_i - 1, n + 2)]});
            edges[idx(col_i, row_i, n + 2)].push(Edge {node: idx(col_i + 1, row_i, n + 2), cost: grid[idx(col_i + 1, row_i, n + 2)]});
            edges[idx(col_i, row_i, n + 2)].push(Edge {node: idx(col_i - 1, row_i, n + 2), cost: grid[idx(col_i - 1, row_i, n + 2)]});
        }
    }
    // for edge in &edges[idx(1, 1, n+2)] {
    //     println!("{}, {}", edge.node, edge.cost);
    // }
    // for edge in &edges[idx(n, n, n+2)] {
    //     println!("{}, {}", edge.node, edge.cost);
    // }

    let mut sum = 0;
    for p in p_vec {
        let converted_idx = idx((p - 1) as usize / n + 1, (p - 1) as usize % n + 1, n + 2);
        // println!("{} -> {}", p, converted_idx);
        let dists = shortest_path(&edges, converted_idx);
        // println!("{:?}", dists);
        let mut min = 1_000_000_000;
        // println!("{:?}", dists);
        for i in 1..n+1 {
            if dists[idx(0, i, n + 2)] < min {
                min = dists[idx(0, i, n + 2)];
            }
            if dists[idx(i, 0, n + 2)] < min {
                min = dists[idx(i, 0, n + 2)];
            }
            if dists[idx(n+1, i, n + 2)] < min {
                min = dists[idx(n+1, i, n + 2)];
            }
            if dists[idx(i, n+1, n + 2)] < min {
                min = dists[idx(i, n+1, n + 2)];
            }
        }
        // println!("{}, {}", p, min);
        sum += min;
        // edges[converted_idx] = Vec::new();
        edges[converted_idx + 1].push(Edge{node: converted_idx, cost: 0});
        edges[converted_idx - 1].push(Edge{node: converted_idx, cost: 0});
        edges[converted_idx - n - 2].push(Edge{node: converted_idx, cost: 0});
        edges[converted_idx + n + 2].push(Edge{node: converted_idx, cost: 0});
    }
    println!("{}", sum);

}
