using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace AtCoder.Contests.AGC044
{
    /// <summary>
    /// 
    /// </summary>
    static class B
    {
        static int n;
        static bool[,] nn;
        static void Main(string[] args)
        {
            n = NextInt();
            var ps = ReadIntArray();
            nn = new bool[n + 2, n + 2];

            var sum = 0;

            for (int i = 0; i < n * n; i++)
            {
                var p = ps[i];
                var startp = new P { x = (p-1) / n + 1, y = (p-1) % n + 1, d = 0 };
                var mm = new int[n + 2, n + 2];
                var done = new bool[n + 2, n + 2];
                for (int k = 0; k < n + 2; k++)
                {
                    for (int l = 0; l < n + 2; l++)
                    {
                        mm[k, l] = int.MaxValue;
                    }
                }
                var heap = new MinHeap<P>(n*n, (a,b)=>a.d.CompareTo(b.d));
                heap.Push(startp);

                while (heap.Any())
                {
                    var c = heap.Pop();
                    done[c.x, c.y] = true;
                    SetNext(c);
                    foreach (var next in nexts)
                    {
                        if (done[next.x, next.y]) continue;
                        if (mm[next.x, next.y] > next.d)
                        {
                            mm[next.x, next.y] = next.d;
                            heap.Push(next);
                        }
                    }
                }

                nn[startp.x, startp.y] = true;
                sum += mm[0, 0];
            }

            Console.WriteLine(sum);
        }


        static List<P> nexts = new List<P>(4);

        static void SetNext(P c)
        {
            nexts.Clear();
            if (c.x == 0 || c.x == n + 1 || c.y == 0 || c.y == n + 1)
            {
                return;
            }
            if (c.x == 1 || c.x == n || c.y == 1 || c.y == n)
            {
                nexts.Add(new P
                {
                    x = 0,
                    y = 0,
                    d = c.d
                });
                return;
            }
            nexts.Add(new P { x = c.x - 1, y = c.y, d = c.d + (nn[c.x - 1, c.y] ? 0 : 1) });
            nexts.Add(new P { x = c.x + 1, y = c.y, d = c.d + (nn[c.x + 1, c.y] ? 0 : 1) });
            nexts.Add(new P { x = c.x, y = c.y - 1, d = c.d + (nn[c.x, c.y - 1] ? 0 : 1) });
            nexts.Add(new P { x = c.x, y = c.y + 1, d = c.d + (nn[c.x, c.y + 1] ? 0 : 1) });
        }

        //static IEnumerable<P> Enumerate(P current, bool[,] nn, int n)
        //{
        //    if (current.x==0 || current.x==n+1 || current.y==0 || current.y==n+1)
        //    {
        //        yield break;
        //    }

        //    if (current.x == 1 || current.x == n || current.y == 1 || current.y == n)
        //    {
        //        yield return new P
        //        {
        //            x = 0,
        //            y = 0,
        //            d = current.d
        //        };
        //        yield break;
        //    }

        //    yield return new P { x = current.x - 1, y = current.y, d = current.d + (nn[current.x - 1, current.y] ? 0 : 1) };
        //    yield return new P { x = current.x + 1, y = current.y, d = current.d + (nn[current.x + 1, current.y] ? 0 : 1) };
        //    yield return new P { x = current.x, y = current.y - 1, d = current.d + (nn[current.x, current.y - 1] ? 0 : 1) };
        //    yield return new P { x = current.x, y = current.y + 1, d = current.d + (nn[current.x, current.y + 1] ? 0 : 1) };
        //}

        struct P
        {
            public int x;
            public int y;
            public int d;
        }

        #region Console
        static int _index = 0;
        static string[] _buffer;

        static string Next()
        {
            if (_buffer == null || _index >= _buffer.Length)
            {
                _buffer = Console.ReadLine().Split();
                _index = 0;
            }

            return _buffer[_index++];
        }
        static int NextInt()
        {
            return int.Parse(Next());
        }
        static long NextLong()
        {
            return long.Parse(Next());
        }
        static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static int[] ReadIntArray(int n)
        {
            var a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadInt();
            }
            return a;
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
        static long[] ReadLongArray(int n)
        {
            var a = new long[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadLong();
            }
            return a;
        }
        static List<T> ReadObjects<T>(int n, Func<int[], T> creator)
        {
            var l = new List<T>(n);

            for (int i = 0; i < n; i++)
            {
                var a = ReadIntArray();
                l.Add(creator(a));
            }

            return l;
        }

        static int[,] ReadMatrix(int n, int m)
        {
            var r = new int[n, m];
            for (int i = 0; i < n; i++)
            {
                var a = ReadIntArray();
                for (int j = 0; j < m; j++)
                {
                    r[i, j] = a[j];
                }
            }
            return r;
        }
        #endregion
    }

    public class MinHeap<T> : IEnumerable<T>
    {
        private List<T> _list;
        private Comparer<T> _comp;

        public int Count
        {
            get
            {
                return _list.Count;
            }
        }

        public MinHeap() : this(0) { }
        public MinHeap(int capacity, Comparison<T> comp = null)
        {
            _list = new List<T>(capacity);

            if (comp == null)
            {
                _comp = Comparer<T>.Default;
            }
            else
            {
                _comp = Comparer<T>.Create(comp);
            }
        }

        public void Push(T elem)
        {
            Upheap(elem);
        }

        public T Pop()
        {
            return Downheap();
        }

        public T Peek()
        {
            return _list[0];
        }


        private void Swap(int i, int j)
        {
            var a = _list[j];
            _list[j] = _list[i];
            _list[i] = a;
        }

        private void Upheap(T elem)
        {
            _list.Add(elem);
            var i = _list.Count - 1;

            while (true)
            {
                if (i == 0) return;
                var j = (i - 1) / 2;

                var e = _list[i];
                var p = _list[j];

                var c = _comp.Compare(e, p);
                if (c < 0)
                {
                    Swap(i, j);
                    i = j;
                    continue;
                }
                else
                {
                    break;
                }
            }
        }

        private T Downheap()
        {
            var result = _list[0];

            var last = _list.Count - 1;
            Swap(0, last);
            _list.RemoveAt(last);
            if (_list.Count == 0) return result;

            var i = 0;
            while (true)
            {
                if (i == _list.Count - 1) return result;
                var p = _list[i];

                var j = i * 2 + 1;
                if (j >= _list.Count) return result;

                if (j + 1 < _list.Count && _comp.Compare(_list[j], _list[j + 1]) > 0)
                {
                    j++;
                }

                if (_comp.Compare(_list[i], _list[j]) > 0)
                {
                    Swap(i, j);
                    i = j;
                }
                else
                {
                    return result;
                }
            }
        }

        public MinHeap<T> Copy(Comparison<T> comp = null)
        {
            var c = new MinHeap<T>(0, comp);
            c._list = _list.ToList();

            return c;
        }
        public MinHeap(List<T> list)
        {
            _list = list;

            _comp = Comparer<T>.Default;
        }

        public List<T> GetList()
        {
            return _list;
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _list.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}
