#[allow(unused_imports)] use std::cmp::*; #[allow(unused_imports)] use std::collections::*; use std::io::*; #[allow(dead_code)] fn getline() -> String { let mut ret = String::new(); std::io::stdin().read_line(&mut ret).ok(); return ret; } fn get_word() -> String { let mut stdin = std::io::stdin(); let mut u8b: [u8; 1] = [0]; loop { let mut buf: Vec = Vec::with_capacity(16); loop { let res = stdin.read(&mut u8b); if res.is_err() || res.ok().unwrap() == 0 || u8b[0] <= ' ' as u8 { break; } else { buf.push(u8b[0]); } } if buf.len() >= 1 { let ret = std::string::String::from_utf8(buf).unwrap(); return ret; } } } fn parse(s: &str) -> T { s.parse::().ok().unwrap() } #[allow(dead_code)] fn get() -> T { parse(&get_word()) } fn next_permutation(v: &mut [T]) -> usize { let mut tail_dec: usize = 1; let mut n = v.len(); while tail_dec < n { if v[n - tail_dec - 1] > v[n - tail_dec] { tail_dec += 1; } else { break; } } // v[n - tail_dec .. n] is strictly decreasing if tail_dec < n { let x = n - tail_dec - 1; let mut y = n; { let pivot = &v[x]; for i in (n - tail_dec .. n).rev() { if v[i] > *pivot { y = i; break; } } assert!(y < n); } v.swap(x, y); } v[n - tail_dec .. n].sort(); return max(n - tail_dec, 1) - 1; } fn main() { let n: usize = get(); let k: usize = get(); let mut p: Vec = (0 .. n).map(|_| get()).collect(); let b: Vec = (0 .. n).map(|_| get()).collect(); let mut tot: i64 = 0; for _ in 0 .. k { let ret = next_permutation(&mut p); for i in 0 .. n { tot += (p[i] - b[i]).abs(); } } println!("{}", tot); }