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 { stdin: R, } impl Scanner { pub fn read(&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::>(); std::str::from_utf8(&buf).unwrap() .parse() .ok() .expect("Parse error.") } pub fn vec(&mut self, n: usize) -> Vec { (0..n).map(|_| self.read()).collect() } pub fn chars(&mut self) -> Vec { self.read::().chars().collect() } } pub trait BinarySearch { fn lower_bound(&self, x:&T) -> usize; fn upper_bound(&self, x:&T) -> usize; } impl BinarySearch for VecDeque{ 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 BinarySearch 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, ifac:&Vec)->usize{ let mut a = a; let mut b = b; if a == 0 && b == 0{return 1;} if a, ifac:&Vec)->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, Vec){ 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 { 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![0usize;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]].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, dy:&Vec, used:&mut Vec>, now:&mut Vec>, bad:&mut Vec>, c:&Vec>, H:usize, W:usize, C:&Vec> ){ 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, dy:&Vec, used:&mut Vec>, now:&mut Vec>, bad:&mut Vec>, c:&Vec>, H:usize, W:usize, C:&Vec> ){ 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>, 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;