lol

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.StringTokenizer;

/*
ID: leedsja1
LANG: JAVA
TASK: problem
*/
public class art { //Class name
    public static void main(String[] args) throws IOException{
        FastScanner f = new FastScanner("art.in");
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("art.out")));
        int n = f.nextInt();
        int[][] canvas = new int[n][n];
        for (int x = 0; x < n; x++) {
            for (int y = 0; y < n; y++) {
                canvas[x][y] = f.nextInt();
            }
        }
        Rectangle[] rectangles = new Rectangle[n*n+1];
        int numRectangles = 0;
        for (int x = 0; x < n; x++) {
            for (int y = 0; y < n; y++) {
                if (canvas[x][y] != 0 && rectangles[canvas[x][y]] == null) {
                    rectangles[canvas[x][y]] = new Rectangle(x, y, canvas[x][y]);
                    numRectangles++;
                } else if (canvas[x][y] != 0){
                    Rectangle r = rectangles[canvas[x][y]];
                    if (x < r.x1) r.x1 = x;
                    if (x > r.x2) r.x2 = x;
                    if (y < r.y1) r.y1 = y;
                    if (y > r.y2) r.y2 = y;
                }
            }
        }
        if (numRectangles == 1) {
            out.print(n * n - 1);
            out.close();
            return;
        }

        ArrayList<Rectangle> rectangleList = new ArrayList<Rectangle>();
        for (int i = 1; i < n*n+1; i++) if (rectangles[i] != null) rectangleList.add(rectangles[i]);
        ArrayList<Rectangle> x1Rectangles = new ArrayList<>(rectangleList);
        ArrayList<Rectangle> x2Rectangles = new ArrayList<>(rectangleList);
        ArrayList<Rectangle> y1Rectangles = new ArrayList<>();
        ArrayList<Rectangle> y2Rectangles = new ArrayList<>();
        Collections.sort(x1Rectangles, new x1Comparator());
        Collections.sort(x2Rectangles, new x2Comparator());
        boolean[] current = new boolean[n * n + 1];
        boolean[] impossible = new boolean[n * n + 1];
        int curNum = 0;
        int xInserted = 0;
        int xRemoved = 0;
        for (int x = 0; x < n; x++) {
            while (xInserted < x1Rectangles.size() && x1Rectangles.get(xInserted).x1 == x) {
                Rectangle r = x1Rectangles.get(xInserted);
                xInserted++;
                int index = Collections.binarySearch(y1Rectangles, r, new y1Comparator());
                if (index < 0) index = index * -1 - 1;
                y1Rectangles.add(index, r);
                index = Collections.binarySearch(y2Rectangles, r, new y2Comparator());
                if (index < 0) index = index * -1 - 1;
                y2Rectangles.add(index, r);
            }
            int yInserted = 0;
            int yRemoved = 0;
            for (int y = 0; y < n; y++) {
                while (yInserted < y1Rectangles.size() && y1Rectangles.get(yInserted).y1 == y) {
                    Rectangle r = y1Rectangles.get(yInserted);
                    yInserted++;
                    current[r.value] = true;
                    curNum++;
                }
                if (curNum >= 2) {
                    impossible[canvas[x][y]] = true;
                }
                while (yRemoved < y2Rectangles.size() && y2Rectangles.get(yRemoved).y2 == y) {
                    Rectangle r = y2Rectangles.get(yRemoved);
                    yRemoved++;
                    current[r.value] = false;
                    curNum--;
                }
            }

            while (xRemoved < x2Rectangles.size() && x2Rectangles.get(xRemoved).x2 == x) {
                Rectangle r = x2Rectangles.get(xRemoved);
                xRemoved++;
                int index = Collections.binarySearch(y1Rectangles, r, new y1Comparator());
                y1Rectangles.remove(index);
                index = Collections.binarySearch(y2Rectangles, r, new y2Comparator());
                y2Rectangles.remove(index);
            }
        }

        int result = 0;
        for (int i = 1; i <= n * n; i++) {
            if (!impossible[i]) result++;
        }

        out.print(result);
        out.close();
    }

    static class x1Comparator implements Comparator<Rectangle> {
        @Override
        public int compare(Rectangle a, Rectangle b) {
            if (a.x1 > b.x1) return 1;
            if (a.x1 < b.x1) return -1;
            return 0;
        }
    }
    static class x2Comparator implements Comparator<Rectangle> {
        @Override
        public int compare(Rectangle a, Rectangle b) {
            if (a.x2 > b.x2) return 1;
            if (a.x2 < b.x2) return -1;
            return 0;
        }
    }
    static class y1Comparator implements Comparator<Rectangle> {
        @Override
        public int compare(Rectangle a, Rectangle b) {
            if (a.y1 > b.y1) return 1;
            if (a.y1 < b.y1) return -1;
            return 0;
        }
    }
    static class y2Comparator implements Comparator<Rectangle> {
        @Override
        public int compare(Rectangle a, Rectangle b) {
            if (a.y2 > b.y2) return 1;
            if (a.y2 < b.y2) return -1;
            return 0;
        }
    }

    static class Rectangle {
        int x1;
        int y1;
        int x2;
        int y2;
        int value;

        public Rectangle (int x, int y, int v){
            x1 = x;
            x2 = x;
            y1 = y;
            y2 = y;
            value = v;
        }

    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return null;
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}