結果
問題 | No.1124 Earthquake Safety |
ユーザー | akakimidori |
提出日時 | 2020-07-23 12:15:06 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 349 ms / 3,000 ms |
コード長 | 10,666 bytes |
コンパイル時間 | 13,818 ms |
コンパイル使用メモリ | 401,204 KB |
実行使用メモリ | 48,640 KB |
最終ジャッジ日時 | 2024-06-23 17:29:16 |
合計ジャッジ時間 | 29,469 ms |
ジャッジサーバーID (参考情報) |
judge2 / judge5 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,812 KB |
testcase_01 | AC | 1 ms
6,944 KB |
testcase_02 | AC | 1 ms
6,944 KB |
testcase_03 | AC | 1 ms
6,944 KB |
testcase_04 | AC | 1 ms
6,940 KB |
testcase_05 | AC | 1 ms
6,940 KB |
testcase_06 | AC | 1 ms
6,940 KB |
testcase_07 | AC | 5 ms
6,940 KB |
testcase_08 | AC | 58 ms
15,164 KB |
testcase_09 | AC | 288 ms
41,884 KB |
testcase_10 | AC | 88 ms
41,208 KB |
testcase_11 | AC | 1 ms
6,940 KB |
testcase_12 | AC | 1 ms
6,940 KB |
testcase_13 | AC | 2 ms
6,944 KB |
testcase_14 | AC | 335 ms
42,480 KB |
testcase_15 | AC | 341 ms
41,828 KB |
testcase_16 | AC | 349 ms
42,160 KB |
testcase_17 | AC | 349 ms
42,644 KB |
testcase_18 | AC | 304 ms
42,224 KB |
testcase_19 | AC | 299 ms
44,004 KB |
testcase_20 | AC | 304 ms
43,696 KB |
testcase_21 | AC | 305 ms
43,024 KB |
testcase_22 | AC | 300 ms
42,044 KB |
testcase_23 | AC | 278 ms
42,872 KB |
testcase_24 | AC | 298 ms
41,588 KB |
testcase_25 | AC | 268 ms
41,976 KB |
testcase_26 | AC | 265 ms
41,360 KB |
testcase_27 | AC | 256 ms
43,444 KB |
testcase_28 | AC | 255 ms
42,632 KB |
testcase_29 | AC | 241 ms
44,220 KB |
testcase_30 | AC | 259 ms
42,640 KB |
testcase_31 | AC | 264 ms
44,308 KB |
testcase_32 | AC | 245 ms
42,860 KB |
testcase_33 | AC | 220 ms
41,276 KB |
testcase_34 | AC | 222 ms
41,088 KB |
testcase_35 | AC | 265 ms
41,320 KB |
testcase_36 | AC | 215 ms
41,228 KB |
testcase_37 | AC | 257 ms
43,632 KB |
testcase_38 | AC | 242 ms
43,916 KB |
testcase_39 | AC | 228 ms
42,944 KB |
testcase_40 | AC | 223 ms
44,048 KB |
testcase_41 | AC | 222 ms
43,020 KB |
testcase_42 | AC | 217 ms
44,660 KB |
testcase_43 | AC | 234 ms
44,888 KB |
testcase_44 | AC | 222 ms
45,104 KB |
testcase_45 | AC | 220 ms
43,740 KB |
testcase_46 | AC | 229 ms
45,480 KB |
testcase_47 | AC | 233 ms
43,936 KB |
testcase_48 | AC | 247 ms
44,144 KB |
testcase_49 | AC | 253 ms
48,640 KB |
testcase_50 | AC | 1 ms
6,940 KB |
testcase_51 | AC | 1 ms
6,948 KB |
testcase_52 | AC | 1 ms
6,940 KB |
testcase_53 | AC | 1 ms
6,940 KB |
testcase_54 | AC | 1 ms
6,944 KB |
testcase_55 | AC | 1 ms
6,940 KB |
testcase_56 | AC | 1 ms
6,944 KB |
testcase_57 | AC | 1 ms
6,940 KB |
ソースコード
// ---------- begin Rerooting ---------- pub trait RerootingOperator { type Value: Clone; type Edge: Clone; fn init(&mut self, v: usize) -> Self::Value; fn merge(&mut self, p: &Self::Value, c: &Self::Value, e: &Self::Edge) -> Self::Value; } pub struct Rerooting<R: RerootingOperator> { manager: R, size: usize, edge: Vec<(usize, usize, R::Edge, R::Edge)>, } impl<R: RerootingOperator> Rerooting<R> { pub fn new(size: usize, manager: R) -> Self { Rerooting { manager: manager, size: size, edge: vec![], } } #[allow(dead_code)] pub fn add_edge(&mut self, a: usize, b: usize, cost: R::Edge) { assert!(a < self.size && b < self.size && a != b); self.add_edge_bi(a, b, cost.clone(), cost); } #[allow(dead_code)] pub fn add_edge_bi(&mut self, a: usize, b: usize, ab: R::Edge, ba: R::Edge) { assert!(a < self.size && b < self.size && a != b); self.edge.push((a, b, ab, ba)); } pub fn solve(&mut self) -> Vec<R::Value> { let size = self.size; let mut graph = vec![vec![]; size]; for e in self.edge.iter() { graph[e.0].push((e.1, e.2.clone())); graph[e.1].push((e.0, e.3.clone())); } let root = 0; let mut topo = vec![]; let mut parent = vec![root; size]; let mut stack = vec![root]; let mut parent_edge: Vec<Option<R::Edge>> = (0..size).map(|_| None).collect(); while let Some(v) = stack.pop() { topo.push(v); if let Some(k) = graph[v].iter().position(|e| e.0 == parent[v]) { let (_, c) = graph[v].remove(k); parent_edge[v] = Some(c); } for e in graph[v].iter() { parent[e.0] = v; stack.push(e.0); } } assert!(topo.len() == size); let manager = &mut self.manager; let mut down: Vec<_> = (0..size).map(|v| manager.init(v)).collect(); for &v in topo.iter().rev() { for e in graph[v].iter() { down[v] = manager.merge(&down[v], &down[e.0], &e.1); } } let mut up: Vec<_> = (0..size).map(|v| manager.init(v)).collect(); let mut stack = vec![]; for &v in topo.iter() { if let Some(e) = parent_edge[v].take() { let ini = manager.init(v); up[v] = manager.merge(&ini, &up[v], &e); } if !graph[v].is_empty() { stack.push((graph[v].as_slice(), up[v].clone())); while let Some((g, val)) = stack.pop() { if g.len() == 1 { up[g[0].0] = val; } else { let m = g.len() / 2; let (a, b) = g.split_at(m); for a in [(a, b), (b, a)].iter() { let mut p = val.clone(); for a in a.0.iter() { p = manager.merge(&p, &down[a.0], &a.1); } stack.push((a.1, p)); } } } } for e in graph[v].iter() { up[v] = manager.merge(&up[v], &down[e.0], &e.1); } } up } } // ---------- end Rerooting ---------- // ---------- begin ModInt ---------- mod modint { #[allow(dead_code)] pub struct Mod; impl ConstantModulo for Mod { const MOD: u32 = 1_000_000_007; } #[allow(dead_code)] pub struct StaticMod; static mut STATIC_MOD: u32 = 0; impl Modulo for StaticMod { fn modulo() -> u32 { unsafe { STATIC_MOD } } } #[allow(dead_code)] impl StaticMod { pub fn set_modulo(p: u32) { unsafe { STATIC_MOD = p; } } } use std::marker::*; use std::ops::*; pub trait Modulo { fn modulo() -> u32; } pub trait ConstantModulo { const MOD: u32; } impl<T> Modulo for T where T: ConstantModulo, { fn modulo() -> u32 { T::MOD } } pub struct ModularInteger<T>(pub u32, PhantomData<T>); impl<T> Clone for ModularInteger<T> { fn clone(&self) -> Self { ModularInteger::new_unchecked(self.0) } } impl<T> Copy for ModularInteger<T> {} impl<T: Modulo> Add for ModularInteger<T> { type Output = ModularInteger<T>; fn add(self, rhs: Self) -> Self::Output { let mut d = self.0 + rhs.0; if d >= T::modulo() { d -= T::modulo(); } ModularInteger::new_unchecked(d) } } impl<T: Modulo> AddAssign for ModularInteger<T> { fn add_assign(&mut self, rhs: Self) { *self = *self + rhs; } } impl<T: Modulo> Sub for ModularInteger<T> { type Output = ModularInteger<T>; fn sub(self, rhs: Self) -> Self::Output { let mut d = T::modulo() + self.0 - rhs.0; if d >= T::modulo() { d -= T::modulo(); } ModularInteger::new_unchecked(d) } } impl<T: Modulo> SubAssign for ModularInteger<T> { fn sub_assign(&mut self, rhs: Self) { *self = *self - rhs; } } impl<T: Modulo> Mul for ModularInteger<T> { type Output = ModularInteger<T>; fn mul(self, rhs: Self) -> Self::Output { let v = self.0 as u64 * rhs.0 as u64 % T::modulo() as u64; ModularInteger::new_unchecked(v as u32) } } impl<T: Modulo> MulAssign for ModularInteger<T> { fn mul_assign(&mut self, rhs: Self) { *self = *self * rhs; } } impl<T: Modulo> Neg for ModularInteger<T> { type Output = ModularInteger<T>; fn neg(self) -> Self::Output { if self.0 == 0 { Self::zero() } else { Self::new_unchecked(T::modulo() - self.0) } } } impl<T> std::fmt::Display for ModularInteger<T> { fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result { write!(f, "{}", self.0) } } impl<T: Modulo> std::str::FromStr for ModularInteger<T> { type Err = std::num::ParseIntError; fn from_str(s: &str) -> Result<Self, Self::Err> { let val = s.parse::<u32>()?; Ok(ModularInteger::new(val)) } } impl<T: Modulo> From<usize> for ModularInteger<T> { fn from(val: usize) -> ModularInteger<T> { ModularInteger::new_unchecked((val % T::modulo() as usize) as u32) } } impl<T: Modulo> From<i64> for ModularInteger<T> { fn from(val: i64) -> ModularInteger<T> { let m = T::modulo() as i64; ModularInteger::new((val % m + m) as u32) } } #[allow(dead_code)] impl<T> ModularInteger<T> { pub fn new_unchecked(d: u32) -> Self { ModularInteger(d, PhantomData) } pub fn zero() -> Self { ModularInteger::new_unchecked(0) } pub fn one() -> Self { ModularInteger::new_unchecked(1) } pub fn is_zero(&self) -> bool { self.0 == 0 } } #[allow(dead_code)] impl<T: Modulo> ModularInteger<T> { pub fn new(d: u32) -> Self { ModularInteger::new_unchecked(d % T::modulo()) } 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.0 != 0); self.pow(T::modulo() as u64 - 2) } } #[allow(dead_code)] pub fn mod_pow(r: u64, mut n: u64, m: u64) -> u64 { let mut t = 1 % m; let mut s = r % m; while n > 0 { if n & 1 == 1 { t = t * s % m; } s = s * s % m; n >>= 1; } t } } // ---------- end ModInt ---------- //https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より 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_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_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") }; } // use modint::*; type ModInt = ModularInteger<Mod>; struct R { inv: ModInt, } impl RerootingOperator for R { // sum P, PxPy type Value = (ModInt, ModInt); type Edge = (); fn init(&mut self, _v: usize) -> Self::Value { (ModInt::one(), ModInt::zero()) } fn merge(&mut self, p: &Self::Value, c: &Self::Value, _e: &Self::Edge) -> Self::Value { (p.0 + self.inv * c.0, p.1 + self.inv * c.1 + p.0 * c.0) } } fn run() { input! { n: usize, e: [(usize1, usize1); n - 1], } let mut solver = Rerooting::new(n,R{inv: ModInt::new(2).inv()}); for (a, b) in e { solver.add_edge(a, b, ()); } let ans = solver .solve() .into_iter() .fold(ModInt::zero(), |s, a| s + a.0 + a.1) * ModInt::new(2).pow((n - 1) as u64); println!("{}", ans); } fn main() { run(); }