use std::cmp::Ordering;
use std::cmp;
use std::cmp::min;
use std::collections::BTreeMap;
use std::process;
use std::cmp::Ord;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::collections::BTreeSet;
use std::mem;
use std::collections::BinaryHeap;
use std::hash::{Hash, Hasher};

pub struct Scanner<R> {
    stdin: R,
}
 
impl<R: std::io::Read> Scanner<R> {
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        std::str::from_utf8(&buf).unwrap()
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}


pub trait BinarySearch<T> {
    fn lower_bound(&self, x:&T) -> usize;
    fn upper_bound(&self, x:&T) -> usize;
}

impl<T: Ord> BinarySearch<T> for VecDeque<T>{
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }

    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}
impl<T: Ord> BinarySearch<T> for [T]{
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }

    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}
fn comb(a:usize, b:usize,  fac:&Vec<usize>, ifac:&Vec<usize>)->usize{
        let mut a = a;
        let mut b = b;
        if a == 0 && b == 0{return 1;}
        if a<b || a<0{return 0;}
        let mut tmp = ifac[a-b]*ifac[b]%MODu;
        return tmp * fac[a]%MODu;
}
fn nHr(n:usize, r:usize, fac:&Vec<usize>, ifac:&Vec<usize>)->usize{
    return comb(n+r-1, r, fac, ifac);
}
fn modinv(a:usize, M:usize)->usize{
    let mut b = M as i64;
    let mut u = 1 as i64;
    let mut v = 0 as i64;
    let mut a = a as i64;
    let mut m = M as i64;
    while(b>0){
        let mut t = a/b;
        a -= t*b;
        mem::swap(&mut a, &mut b);
        u-=t*v;
        mem::swap(&mut u, &mut v);
    }
    u%=m;
    if u<0{u+=m;}
    return u as usize;

}
fn modpow(x:usize, n:usize) -> usize{
        let mut ans = 1;
        let mut n = n as usize;
        let mut x = x;
        while(n != 0){
            if (n&1 == 1){ans = ans*x%MODu;}
            x = x*x%MODu;
            n = n>>1;
        }
        ans
}
fn invs(max:usize)->(Vec<usize>, Vec<usize>){
    let mut fac = vec![0;max+1];
    let mut ifac = vec![0;max+1];
    fac[0] = 1;
    ifac[0] = 1;
    for i in 0..max{

        fac[i+1] = fac[i] * (i+1)%MODu;
        ifac[i+1] = ifac[i] * modpow(i+1, MODu - 2)%MODu;
    }
    (fac, ifac)
}

#[derive(Copy, Clone, Eq, PartialEq)]
struct x{    
             a:i64,   
             b:i64, 
             c:i64,   
             d:i64,   
}            
impl Ord for x{
    fn cmp(&self, other:&Self)->Ordering{
                 (other.b * (self.a)).cmp(&((self.b)*other.a))
             }        
         }            
         impl PartialOrd for x {
             fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
                 Some(self.cmp(other))
             }        
         }          
fn gcd(a:usize, b:usize)->usize{
    if b==0{return a;}
    return gcd(b, a%b);
}
fn solve(){
    let sssss = std::io::stdin();

    let mut sc = Scanner { stdin: sssss.lock() };
    let mut H:usize = sc.read();
    let mut W:usize = sc.read();
    let mut N:usize = sc.read();
    let mut C = vec![vec![0u16;W];H];
    let mut c= vec![vec![];N];
    for i in 0..H{
        for j in 0..W{
            C[i][j] = sc.read();
            C[i][j]-=1;
            c[C[i][j] as usize].push((i, j));
        }
    }
    let mut dp = vec![vec![INFu;N+1];N+1];
    let mut s = 0;
    let mut t = 1;
    let mut used = vec![vec![false;W];H];
    fn add(cc:usize, 
           dx:&Vec<i64>, 
           dy:&Vec<i64>, 
           used:&mut Vec<Vec<bool>>, 
           now:&mut Vec<Vec<u8>>, 
           bad:&mut Vec<HashSet<(usize, usize)>>,
           c:&Vec<Vec<(usize, usize)>>,
           H:usize,
           W:usize,
           C:&Vec<Vec<u16>>
           ){
        for i in 0..c[cc].len(){
            used[c[cc][i].0][c[cc][i].1] = true;
        }
        for i in 0..c[cc].len(){
            for j in 0..4{
                let mut nx = c[cc][i].0 as i64 + dx[j];
                let mut ny = c[cc][i].1 as i64 + dy[j];
                if 0<=nx && nx<H as i64 && 0<=ny && ny<W as i64{
                    let mut nx = nx as usize;
                    let mut ny = ny as usize;
                    if used[nx][ny]{
                        continue;
                    }
                    if now[nx][ny] == 0{
                        bad[C[nx][ny] as usize].insert((nx, ny));
                    }
                    now[nx][ny]+=1;
                }
            }
        }
    }
    fn subtract(cc:usize,
           dx:&Vec<i64>,
           dy:&Vec<i64>,
           used:&mut Vec<Vec<bool>>,
           now:&mut Vec<Vec<u8>>,
           bad:&mut Vec<HashSet<(usize, usize)>>,
           c:&Vec<Vec<(usize, usize)>>,
           H:usize,
           W:usize,
           C:&Vec<Vec<u16>>
           ){
        for i in 0..c[cc].len(){
            for j in 0..4{
                let mut nx = c[cc][i].0 as i64 + dx[j];
                let mut ny = c[cc][i].1 as i64 + dy[j];
                if 0<=nx && nx<H as i64 && 0<=ny && ny<W as i64{
                    let mut nx = nx as usize;
                    let mut ny = ny as usize;
                    if used[nx][ny]{
                        continue;
                    }
                    now[nx][ny]-=1;
                    if now[nx][ny] == 0{
                        bad[C[nx][ny] as usize].remove(&(nx, ny));
                    }
                }
            }

        }
        for i in 0..c[cc].len(){
            used[c[cc][i].0][c[cc][i].1] = false;
        }

    }
    let mut s = 0;
    let mut t = 0;

    let mut bad = vec![HashSet::new();N];
    let mut now = vec![vec![0u8;W];H];
    let mut dx = vec![0, 0, -1, 1];
    let mut dy = vec![1, -1, 0, 0];
    dp[s][t] = 1;
    let mut span = HashSet::new();
    while(s<N){
        while(t<N && bad[t].len() == 0){
            add(t, &dx, &dy, &mut used, &mut now, &mut bad,&c, H, W, &C);
            t+=1;
            for ss in s..t{

                dp[ss][t] = 1;
                span.insert((ss, t));
            }
        }
        subtract(s, &dx, &dy, &mut used, &mut now, &mut bad,&c, H, W, &C);
        s+=1;
    }
    fn dfs(l:usize, r:usize, dp:&mut Vec<Vec<usize>>, span:&HashSet<(usize, usize)>)->usize{
        let mut res = INFu;
        if dp[l][r]  != INFu{
            return dp[l][r];
        }
        for i in l+1..r{
            if span.contains(&(l, i)){
                res = cmp::min(res, 1+dfs(i, r, dp, span));
            }
            else{
                res = cmp::min(res, i-l+dfs(i, r, dp, span));
            }
        }
        dp[l][r] = res;
        return res;
    }
    println!("{}", dfs(0, N, &mut dp, &span));





}
    
fn main(){
    solve();
}


const PI:f64 = std::f64::consts::PI;
pub static MOD:i64    = 998244353;
pub static MODu:usize = 1000000007;
pub static MODi32:i32 = 1000000007;
pub static eps:f64 = 1e-6;
const INF: i64 = 1 << 60;
const INFu:usize = 1<<56;
const INFu128:u128 = 1<<126;