結果
問題 | No.2405 Minimal Matrix Decomposition |
ユーザー | akakimidori |
提出日時 | 2023-08-04 22:45:56 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 231 ms / 2,000 ms |
コード長 | 10,491 bytes |
コンパイル時間 | 14,325 ms |
コンパイル使用メモリ | 381,224 KB |
実行使用メモリ | 5,760 KB |
最終ジャッジ日時 | 2024-10-14 20:51:27 |
合計ジャッジ時間 | 19,254 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge5 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
5,248 KB |
testcase_01 | AC | 1 ms
5,248 KB |
testcase_02 | AC | 1 ms
5,248 KB |
testcase_03 | AC | 1 ms
5,248 KB |
testcase_04 | AC | 8 ms
5,248 KB |
testcase_05 | AC | 231 ms
5,760 KB |
testcase_06 | AC | 1 ms
5,248 KB |
testcase_07 | AC | 1 ms
5,248 KB |
testcase_08 | AC | 1 ms
5,248 KB |
testcase_09 | AC | 1 ms
5,248 KB |
testcase_10 | AC | 64 ms
5,248 KB |
testcase_11 | AC | 81 ms
5,248 KB |
testcase_12 | AC | 2 ms
5,248 KB |
testcase_13 | AC | 14 ms
5,248 KB |
testcase_14 | AC | 20 ms
5,248 KB |
testcase_15 | AC | 6 ms
5,248 KB |
testcase_16 | AC | 4 ms
5,248 KB |
testcase_17 | AC | 32 ms
5,248 KB |
testcase_18 | AC | 25 ms
5,248 KB |
testcase_19 | AC | 23 ms
5,248 KB |
testcase_20 | AC | 1 ms
5,248 KB |
testcase_21 | AC | 5 ms
5,248 KB |
testcase_22 | AC | 59 ms
5,248 KB |
testcase_23 | AC | 2 ms
5,248 KB |
testcase_24 | AC | 2 ms
5,248 KB |
testcase_25 | AC | 3 ms
5,248 KB |
testcase_26 | AC | 48 ms
5,248 KB |
testcase_27 | AC | 13 ms
5,248 KB |
testcase_28 | AC | 49 ms
5,248 KB |
testcase_29 | AC | 10 ms
5,248 KB |
testcase_30 | AC | 55 ms
5,248 KB |
testcase_31 | AC | 19 ms
5,248 KB |
testcase_32 | AC | 2 ms
5,248 KB |
testcase_33 | AC | 41 ms
5,248 KB |
testcase_34 | AC | 7 ms
5,248 KB |
testcase_35 | AC | 1 ms
5,248 KB |
testcase_36 | AC | 12 ms
5,248 KB |
testcase_37 | AC | 22 ms
5,248 KB |
testcase_38 | AC | 30 ms
5,248 KB |
testcase_39 | AC | 58 ms
5,248 KB |
testcase_40 | AC | 17 ms
5,248 KB |
testcase_41 | AC | 3 ms
5,248 KB |
testcase_42 | AC | 52 ms
5,248 KB |
testcase_43 | AC | 10 ms
5,248 KB |
testcase_44 | AC | 12 ms
5,248 KB |
testcase_45 | AC | 4 ms
5,248 KB |
testcase_46 | AC | 11 ms
5,248 KB |
testcase_47 | AC | 15 ms
5,248 KB |
testcase_48 | AC | 5 ms
5,248 KB |
testcase_49 | AC | 2 ms
5,248 KB |
ソースコード
fn main() { input! { p: u32, h: usize, w: usize, a: [[u32; w]; h], } StaticMod::set_modulo(p); let mat = a .into_iter() .map(|a| a.into_iter().map(|a| M::new(a)).collect()) .collect::<Vec<Vec<_>>>(); let mut ans = vec![mat.clone()]; let mut a = mat.clone(); let mut s = 0; for j in 0..w { if let Some(x) = (s..h).find(|&x| !a[x][j].is_zero()) { a.swap(s, x); let mut src = std::mem::take(&mut a[s]); let inv = src[j].inv(); for a in src.iter_mut() { *a *= inv; } for i in 0..h { if i != s { let mul = a[i][j]; for (a, s) in a[i].iter_mut().zip(src.iter()) { *a -= mul * *s; } } } a[s] = src; s += 1; } } a.truncate(s); let mut b = vec![vec![M::zero(); a.len()]; h]; if a.len() == 0 { a = vec![vec![M::zero(); w]]; b = vec![vec![M::zero()]; h]; } else { for (b, mat) in b.iter_mut().zip(mat.iter()) { for (b, a) in b.iter_mut().zip(a.iter()) { let x = a.iter().position(|a| !a.is_zero()).unwrap(); *b = mat[x]; } } } if h * w > (h + w) * a.len() { ans = vec![b, a]; } use util::*; println!("{}", ans.len()); for a in ans { println!("{} {}", a.len(), a[0].len()); for a in a { println!("{}", a.iter().join(" ")); } } } // ---------- begin input macro ---------- // reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 #[macro_export] macro_rules! input { (source = $s:expr, $($r:tt)*) => { let mut iter = $s.split_whitespace(); input_inner!{iter, $($r)*} }; ($($r:tt)*) => { let s = { use std::io::Read; let mut s = String::new(); std::io::stdin().read_to_string(&mut s).unwrap(); s }; let mut iter = s.split_whitespace(); input_inner!{iter, $($r)*} }; } #[macro_export] macro_rules! input_inner { ($iter:expr) => {}; ($iter:expr, ) => {}; ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { let $var = read_value!($iter, $t); input_inner!{$iter $($r)*} }; } #[macro_export] macro_rules! read_value { ($iter:expr, ( $($t:tt),* )) => { ( $(read_value!($iter, $t)),* ) }; ($iter:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>() }; ($iter:expr, chars) => { read_value!($iter, String).chars().collect::<Vec<char>>() }; ($iter:expr, bytes) => { read_value!($iter, String).bytes().collect::<Vec<u8>>() }; ($iter:expr, usize1) => { read_value!($iter, usize) - 1 }; ($iter:expr, $t:ty) => { $iter.next().unwrap().parse::<$t>().expect("Parse error") }; } // ---------- end input macro ---------- mod modint { use std::marker::*; use std::ops::*; pub trait Modulo { fn modulo() -> u32; fn im() -> u64; fn reduce(z: u64) -> u32 { let x = (z as u128 * Self::im() as u128 >> 64) as u32; let mut v = z as u32 - x * Self::modulo(); if v >= Self::modulo() { v += Self::modulo(); } v } } pub struct StaticMod; static mut STATIC_MOD: u32 = 0; static mut STATIC_MOD_IM: u64 = 0; impl Modulo for StaticMod { fn modulo() -> u32 { unsafe { STATIC_MOD } } fn im() -> u64 { unsafe { STATIC_MOD_IM } } } #[allow(dead_code)] impl StaticMod { pub fn set_modulo(p: u32) { unsafe { STATIC_MOD = p; STATIC_MOD_IM = (!0u64 / p as u64) + 1; } } } pub struct ModInt<T>(u32, PhantomData<T>); impl<T> Clone for ModInt<T> { fn clone(&self) -> Self { ModInt::build(self.0) } } impl<T> Copy for ModInt<T> {} impl<T: Modulo> Add for ModInt<T> { type Output = ModInt<T>; fn add(self, rhs: Self) -> Self::Output { let mut d = self.0 + rhs.0; if d >= T::modulo() { d -= T::modulo(); } Self::build(d) } } impl<T: Modulo> AddAssign for ModInt<T> { fn add_assign(&mut self, rhs: Self) { *self = *self + rhs; } } impl<T: Modulo> Sub for ModInt<T> { type Output = ModInt<T>; fn sub(self, rhs: Self) -> Self::Output { let mut d = self.0 - rhs.0; if self.0 < rhs.0 { d += T::modulo(); } Self::build(d) } } impl<T: Modulo> SubAssign for ModInt<T> { fn sub_assign(&mut self, rhs: Self) { *self = *self - rhs; } } impl<T: Modulo> Mul for ModInt<T> { type Output = ModInt<T>; fn mul(self, rhs: Self) -> Self::Output { Self::build(T::reduce(self.0 as u64 * rhs.0 as u64)) } } impl<T: Modulo> MulAssign for ModInt<T> { fn mul_assign(&mut self, rhs: Self) { *self = *self * rhs; } } impl<T: Modulo> Neg for ModInt<T> { type Output = ModInt<T>; fn neg(self) -> Self::Output { if self.0 == 0 { Self::zero() } else { Self::build(T::modulo() - self.0) } } } impl<T: Modulo> std::fmt::Display for ModInt<T> { fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result { write!(f, "{}", self.get()) } } impl<T: Modulo> std::fmt::Debug for ModInt<T> { fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result { write!(f, "{}", self.get()) } } impl<T: Modulo> Default for ModInt<T> { fn default() -> Self { Self::zero() } } impl<T: Modulo> std::str::FromStr for ModInt<T> { type Err = std::num::ParseIntError; fn from_str(s: &str) -> Result<Self, Self::Err> { let val = s.parse::<u32>()?; Ok(ModInt::new(val)) } } impl<T: Modulo> From<usize> for ModInt<T> { fn from(val: usize) -> ModInt<T> { ModInt::new_unchecked((val % T::modulo() as usize) as u32) } } impl<T: Modulo> From<u64> for ModInt<T> { fn from(val: u64) -> ModInt<T> { ModInt::new_unchecked((val % T::modulo() as u64) as u32) } } impl<T: Modulo> From<i64> for ModInt<T> { fn from(val: i64) -> ModInt<T> { let m = T::modulo() as i64; ModInt::new((val % m + m) as u32) } } #[allow(dead_code)] impl<T> ModInt<T> { fn build(d: u32) -> Self { ModInt(d, PhantomData) } pub fn zero() -> Self { Self::build(0) } pub fn is_zero(&self) -> bool { self.0 == 0 } } #[allow(dead_code)] impl<T: Modulo> ModInt<T> { pub fn new_unchecked(d: u32) -> Self { Self::build(d) } pub fn new(d: u32) -> Self { Self::new_unchecked(d % T::modulo()) } pub fn one() -> Self { Self::new_unchecked(1) } pub fn get(&self) -> u32 { self.0 } pub fn pow(&self, mut n: u64) -> Self { let mut t = Self::one(); let mut s = *self; while n > 0 { if n & 1 == 1 { t *= s; } s *= s; n >>= 1; } t } pub fn inv(&self) -> Self { assert!(!self.is_zero()); self.pow((T::modulo() - 2) as u64) } } } // ---------- end ModInt ---------- // ---------- begin Precalc ---------- mod precalc { use super::modint::*; #[allow(dead_code)] pub struct Precalc<T> { inv: Vec<ModInt<T>>, fact: Vec<ModInt<T>>, ifact: Vec<ModInt<T>>, } #[allow(dead_code)] impl<T: Modulo> Precalc<T> { pub fn new(n: usize) -> Precalc<T> { let mut inv = vec![ModInt::one(); n + 1]; let mut fact = vec![ModInt::one(); n + 1]; let mut ifact = vec![ModInt::one(); n + 1]; for i in 2..(n + 1) { fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32); } ifact[n] = fact[n].inv(); if n > 0 { inv[n] = ifact[n] * fact[n - 1]; } for i in (1..n).rev() { ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32); inv[i] = ifact[i] * fact[i - 1]; } Precalc { inv: inv, fact: fact, ifact: ifact, } } pub fn inv(&self, n: usize) -> ModInt<T> { assert!(n > 0); self.inv[n] } pub fn fact(&self, n: usize) -> ModInt<T> { self.fact[n] } pub fn ifact(&self, n: usize) -> ModInt<T> { self.ifact[n] } pub fn perm(&self, n: usize, k: usize) -> ModInt<T> { if k > n { return ModInt::zero(); } self.fact[n] * self.ifact[n - k] } pub fn comb(&self, n: usize, k: usize) -> ModInt<T> { if k > n { return ModInt::zero(); } self.fact[n] * self.ifact[k] * self.ifact[n - k] } } } // ---------- end Precalc ---------- use modint::*; type M = ModInt<StaticMod>; mod util { pub trait Join { fn join(self, sep: &str) -> String; } impl<T, I> Join for I where I: Iterator<Item = T>, T: std::fmt::Display, { fn join(self, sep: &str) -> String { let mut s = String::new(); use std::fmt::*; for (i, v) in self.enumerate() { if i > 0 { write!(&mut s, "{}", sep).ok(); } write!(&mut s, "{}", v).ok(); } s } } }