### BUGGY CODE ###

N = int(input())
P = [int(c)-1 for c in input().split()]
Mat = [[min(y, N-1-y, x, N-1-x) for y in range(N)] for x in range(N)]
Removed = [[0]*N for x in range(N)]
# for m in Mat:
#     print(m)
# print()
Dy, Dx = [1,0,-1,0], [0,1,0,-1]
ans = 0
for p in P:
    y, x = divmod(p, N)
    ans += Mat[y][x]
    #print(p, Mat[y][x])
    Removed[y][x] = True
    #Mat[y][x] -= 1
    st = [(y, x)]
    closed = {(y,x)}
    while st:
        vy, vx = st.pop()
        vr = Removed[vy][vx]
        val = Mat[vy][vx]
        for dy, dx in zip(Dy, Dx):
            uy = vy + dy
            ux = vx + dx
            if not (0<=uy<N and 0<=ux<N):
                continue
            if (uy, ux) in closed:
                continue
            ur = Removed[uy][ux]
            if vr:
                if Mat[uy][ux] >= val+1:
                    Mat[uy][ux] = val
                    st.append((uy, ux))
                    closed.add((uy, ux))
            else:
                if Mat[uy][ux] >= val+2:
                    Mat[uy][ux] = val+1
                    st.append((uy, ux))
                    closed.add((uy, ux))
# for m in Mat:
#     print(m)
print(ans)



# Parents = [[] for _ in range(N*N)]
# Children = [set() for _ in range(N*N)]
# for yx in range(N*N):
#     y, x = divmod(yx, N)
#     v = Mat[y][x]
#     for dy, dx in zip(Dy, Dx):
#         uy = y + dy
#         ux = x + dx
#         uyx = uy*N + ux
#         if not (0<=uy<N and 0<=ux<N):
#             continue
#         u = Mat[uy][ux]
#         if u < v:
#             Parents[uyx].append(yx)
#             Children[yx].append(uyx)
#         elif u > v:
#             Parents[yx].append(uyx)
#             Children[uyx].append(yx)
# for p in P:
#     y, x = divmod(p, N)
#     ans += Mat[y][x]
#     #print(p, Mat[y][x])
#     Mat[y][x] -= 1
#     st = [(y, x)]
#     for parent in Parents[]:
#         for child in Children:
            
#     while st:
#         vy, vx = st.pop()
#         val = Mat[vy][vx]
#         for dy, dx in zip(Dy, Dx):
#             uy = vy + dy
#             ux = vx + dx
#             if not (0<=uy<N and 0<=ux<N):
#                 continue
#             if Mat[uy][ux] - 2 == val:
#                 Mat[uy][ux] -= 1
#                 st.append((uy, ux))





### FIXED CODE ###

import numba
import numpy as np
N = int(input())
P = np.array([int(c)-1 for c in input().split()])

#from random import shuffle
#N = 500
#P = list(range(N*N))
#shuffle(P)
#P = np.array(P)

@numba.njit("void(i8,i8[:])")
def proc(N, P):
    ans = 0
    Removed = np.zeros((500, 500), dtype=np.int8)
    Mat = np.zeros((500, 500), dtype=np.int16)
    Dy, Dx = [1,0,-1,0], [0,1,0,-1]

    for y in range(N):
        for x in range(N):
            Mat[y, x] = min(y, N-1-y, x, N-1-x)
    #print(Mat)
    for i in range(N*N):
        p = P[i]
        y, x = divmod(p, N)
        ans += Mat[y,x]
        Removed[y,x] = 1
        st = [(y, x)]
        while st:
            vy, vx = st.pop()
            vr = Removed[vy,vx]
            val = Mat[vy,vx]
            #for dy, dx in zip(Dy, Dx):
            for j in range(4):
                dy = Dy[j]
                dx = Dx[j]
                uy = vy + dy
                ux = vx + dx
                if not (0<=uy<N and 0<=ux<N):
                    continue
                ur = Removed[uy,ux]
                if vr:
                    if Mat[uy,ux] >= val+1:
                        Mat[uy,ux] = val
                        st.append((uy, ux))
                else:
                    if Mat[uy,ux] >= val+2:
                        Mat[uy,ux] = val+1
                        st.append((uy, ux))
    # for m in Mat:
    #     print(m)
    print(ans)
proc(N, P)