結果
問題 | No.2277 Honest or Dishonest ? |
ユーザー | tipstar0125 |
提出日時 | 2023-04-22 15:23:55 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 77 ms / 2,000 ms |
コード長 | 9,806 bytes |
コンパイル時間 | 16,747 ms |
コンパイル使用メモリ | 378,632 KB |
実行使用メモリ | 12,032 KB |
最終ジャッジ日時 | 2024-11-08 06:53:22 |
合計ジャッジ時間 | 17,840 ms |
ジャッジサーバーID (参考情報) |
judge1 / judge4 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
5,248 KB |
testcase_01 | AC | 2 ms
5,248 KB |
testcase_02 | AC | 1 ms
5,248 KB |
testcase_03 | AC | 57 ms
8,960 KB |
testcase_04 | AC | 60 ms
10,496 KB |
testcase_05 | AC | 24 ms
6,912 KB |
testcase_06 | AC | 46 ms
7,296 KB |
testcase_07 | AC | 36 ms
6,784 KB |
testcase_08 | AC | 20 ms
6,656 KB |
testcase_09 | AC | 39 ms
8,192 KB |
testcase_10 | AC | 26 ms
5,376 KB |
testcase_11 | AC | 11 ms
5,248 KB |
testcase_12 | AC | 19 ms
5,248 KB |
testcase_13 | AC | 54 ms
8,320 KB |
testcase_14 | AC | 24 ms
5,504 KB |
testcase_15 | AC | 20 ms
6,016 KB |
testcase_16 | AC | 38 ms
6,784 KB |
testcase_17 | AC | 17 ms
5,248 KB |
testcase_18 | AC | 59 ms
10,368 KB |
testcase_19 | AC | 58 ms
10,240 KB |
testcase_20 | AC | 43 ms
8,192 KB |
testcase_21 | AC | 34 ms
6,272 KB |
testcase_22 | AC | 35 ms
7,296 KB |
testcase_23 | AC | 47 ms
7,552 KB |
testcase_24 | AC | 32 ms
7,040 KB |
testcase_25 | AC | 48 ms
9,344 KB |
testcase_26 | AC | 14 ms
5,376 KB |
testcase_27 | AC | 23 ms
5,248 KB |
testcase_28 | AC | 21 ms
6,016 KB |
testcase_29 | AC | 35 ms
7,680 KB |
testcase_30 | AC | 22 ms
5,248 KB |
testcase_31 | AC | 40 ms
7,296 KB |
testcase_32 | AC | 30 ms
7,296 KB |
testcase_33 | AC | 56 ms
9,856 KB |
testcase_34 | AC | 58 ms
9,472 KB |
testcase_35 | AC | 7 ms
5,248 KB |
testcase_36 | AC | 34 ms
6,656 KB |
testcase_37 | AC | 54 ms
8,064 KB |
testcase_38 | AC | 10 ms
5,248 KB |
testcase_39 | AC | 14 ms
5,248 KB |
testcase_40 | AC | 8 ms
5,248 KB |
testcase_41 | AC | 66 ms
9,984 KB |
testcase_42 | AC | 44 ms
7,680 KB |
testcase_43 | AC | 75 ms
11,904 KB |
testcase_44 | AC | 74 ms
11,904 KB |
testcase_45 | AC | 77 ms
11,904 KB |
testcase_46 | AC | 75 ms
11,904 KB |
testcase_47 | AC | 75 ms
11,904 KB |
testcase_48 | AC | 75 ms
11,904 KB |
testcase_49 | AC | 77 ms
11,904 KB |
testcase_50 | AC | 74 ms
12,032 KB |
testcase_51 | AC | 77 ms
11,904 KB |
testcase_52 | AC | 75 ms
11,904 KB |
ソースコード
#![allow(non_snake_case)] #![allow(unused_imports)] #![allow(unused_macros)] #![allow(clippy::needless_range_loop)] #![allow(clippy::comparison_chain)] #![allow(clippy::nonminimal_bool)] #![allow(clippy::neg_multiply)] #![allow(dead_code)] use std::collections::{BTreeMap, VecDeque}; use std::ops; // const MOD: usize = 1e9 as usize + 7; const MOD: usize = 998244353; // const MOD: usize = 2147483647; fn read<T: std::str::FromStr>() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } fn read_vec<T: std::str::FromStr>() -> Vec<T> { read::<String>() .split_whitespace() .map(|e| e.parse().ok().unwrap()) .collect() } #[macro_export] macro_rules! max { ($x: expr) => ($x); ($x: expr, $( $y: expr ),+) => { std::cmp::max($x, max!($( $y ),+)) } } #[macro_export] macro_rules! min { ($x: expr) => ($x); ($x: expr, $( $y: expr ),+) => { std::cmp::min($x, min!($( $y ),+)) } } #[derive(Debug, Clone)] struct UnionFind { parent: Vec<isize>, size: usize, } impl UnionFind { fn new(n: usize) -> Self { UnionFind { parent: vec![-1; n], size: n, } } fn find(&mut self, x: usize) -> usize { if self.parent[x] < 0 { return x; } let root = self.find(self.parent[x] as usize); self.parent[x] = root as isize; root } fn unite(&mut self, x: usize, y: usize) -> Option<(usize, usize)> { let root_x = self.find(x); let root_y = self.find(y); if root_x == root_y { return None; } let size_x = -self.parent[root_x]; let size_y = -self.parent[root_y]; self.size -= 1; if size_x >= size_y { self.parent[root_x] -= size_y; self.parent[root_y] = root_x as isize; Some((root_x, root_y)) } else { self.parent[root_y] -= size_x; self.parent[root_x] = root_y as isize; Some((root_y, root_x)) } } fn is_same(&mut self, x: usize, y: usize) -> bool { self.find(x) == self.find(y) } fn is_root(&mut self, x: usize) -> bool { self.find(x) == x } fn get_union_size(&mut self, x: usize) -> usize { let root = self.find(x); -self.parent[root] as usize } fn get_size(&self) -> usize { self.size } fn roots(&self) -> Vec<usize> { (0..self.parent.len()) .filter(|i| self.parent[*i] < 0) .collect::<Vec<usize>>() } fn members(&mut self, x: usize) -> Vec<usize> { let root = self.find(x); (0..self.parent.len()) .filter(|i| self.find(*i) == root) .collect::<Vec<usize>>() } fn all_group_members(&mut self) -> BTreeMap<usize, Vec<usize>> { let mut groups_map: BTreeMap<usize, Vec<usize>> = BTreeMap::new(); for x in 0..self.parent.len() { let r = self.find(x); groups_map.entry(r).or_default().push(x); } groups_map } } type M = ModInt; #[derive(Debug, Clone, Copy)] struct ModInt { value: usize, } impl ModInt { fn new(n: usize) -> Self { ModInt { value: n % MOD } } fn zero() -> Self { ModInt { value: 0 } } fn one() -> Self { ModInt { value: 1 } } fn value(&self) -> usize { self.value } fn pow(&self, n: usize) -> Self { let mut p = *self; let mut ret = ModInt::one(); let mut nn = n; while nn > 0 { if nn & 1 == 1 { ret *= p; } p *= p; nn >>= 1; } ret } fn inv(&self) -> Self { ModInt::new((ext_gcd(self.value, MOD).0 + MOD as isize) as usize) } } impl ops::Add for ModInt { type Output = ModInt; fn add(self, other: Self) -> Self { ModInt::new(self.value + other.value) } } impl ops::Sub for ModInt { type Output = ModInt; fn sub(self, other: Self) -> Self { ModInt::new(MOD + self.value - other.value) } } impl ops::Mul for ModInt { type Output = ModInt; fn mul(self, other: Self) -> Self { ModInt::new(self.value * other.value) } } #[allow(clippy::suspicious_arithmetic_impl)] impl ops::Div for ModInt { type Output = ModInt; fn div(self, other: Self) -> Self { self * other.inv() } } impl ops::AddAssign for ModInt { fn add_assign(&mut self, other: Self) { *self = *self + other; } } impl ops::SubAssign for ModInt { fn sub_assign(&mut self, other: Self) { *self = *self - other; } } impl ops::MulAssign for ModInt { fn mul_assign(&mut self, other: Self) { *self = *self * other; } } impl ops::DivAssign for ModInt { fn div_assign(&mut self, other: Self) { *self = *self / other; } } #[derive(Debug, Clone)] struct Comb { fact: Vec<ModInt>, fact_inverse: Vec<ModInt>, } impl Comb { fn new(n: usize) -> Self { let mut fact = vec![M::one(), M::one()]; let mut fact_inverse = vec![M::one(), M::one()]; let mut inverse = vec![M::zero(), M::one()]; for i in 2..=n { fact.push(*fact.last().unwrap() * M::new(i)); inverse.push((M::zero() - inverse[MOD % i]) * M::new(MOD / i)); fact_inverse.push(*fact_inverse.last().unwrap() * *inverse.last().unwrap()); } Comb { fact, fact_inverse } } fn nCr(&self, n: usize, r: usize) -> ModInt { self.fact[n] * self.fact_inverse[n - r] * self.fact_inverse[r] } fn nHr(&self, n: usize, r: usize) -> ModInt { self.nCr(n + r - 1, r) } } #[derive(Default)] struct Solver {} impl Solver { fn solve(&mut self) { let v: Vec<usize> = read_vec(); let (N, Q) = (v[0], v[1]); let mut G = vec![vec![]; N]; for _ in 0..Q { let abc: Vec<usize> = read_vec(); let a = abc[0] - 1; let b = abc[1] - 1; let c = abc[2]; G[a].push((b, c)); G[b].push((a, c)); } let mut ans = M::one(); let mut visited = vec![-1; N]; for i in 0..N { if visited[i] != -1 { continue; } let mut ok = true; let mut Q = VecDeque::new(); Q.push_back(i); visited[i] = 0; while !Q.is_empty() { let pos = Q.pop_front().unwrap(); for &(next, c) in &G[pos] { if visited[next] == -1 { if (visited[pos] == 0 && c == 0) || (visited[pos] == 1 && c == 1) { visited[next] = 0; } else { visited[next] = 1; } Q.push_back(next); } else if (visited[pos] == 0 && c == 0) || (visited[pos] == 1 && c == 1) { if visited[next] != 0 { ok = false; } } else if visited[next] != 1 { ok = false; } } } if ok { ans *= M::new(2); } else { ans *= M::new(0); } } println!("{}", ans.value()); } } fn main() { std::thread::Builder::new() .stack_size(128 * 1024 * 1024) .spawn(|| Solver::default().solve()) .unwrap() .join() .unwrap(); } fn eratosthenes(n: usize) -> Vec<bool> { let mut is_prime_list = vec![true; n + 1]; is_prime_list[0] = false; is_prime_list[1] = false; let mut i = 2; while i * i <= n { if is_prime_list[i] { let mut j = i * i; while j <= n { is_prime_list[j] = false; j += i; } } i += 1 } is_prime_list } fn legendre(n: usize, p: usize) -> usize { let mut cnt = 0_usize; let mut pp = p; while pp <= n { cnt += n / pp; pp *= p; } cnt } fn mod_pow(a: usize, b: usize) -> usize { let mut p = a; let mut ret = 1; let mut n = b; while n > 0 { if n & 1 == 1 { ret = ret * p % MOD; } p = p * p % MOD; n >>= 1; } ret } fn mod_pow2(a: usize, b: usize, m: usize) -> usize { let mut p = a; let mut ret = 1; let mut n = b; while n > 0 { if n & 1 == 1 { ret = ret * p % m; } p = p * p % m; n >>= 1; } ret } fn mod_inv(a: usize, b: usize) -> usize { (a * mod_pow(b, MOD - 2)) % MOD } fn prime_factorize(n: usize) -> BTreeMap<usize, usize> { let mut nn = n; let mut i = 2; let mut pf: BTreeMap<usize, usize> = BTreeMap::new(); while i * i <= n { while nn % i == 0 { *pf.entry(i).or_default() += 1; nn /= i; } i += 1; } if nn != 1 { *pf.entry(nn).or_default() += 1; } pf } fn enum_dividers(n: usize) -> Vec<usize> { let mut i = 1_usize; let mut ret = vec![]; while i * i <= n { if n % i == 0 { ret.push(i); if i != n / i { ret.push(n / i); } } i += 1; } ret.sort(); ret } // ax+by=gcd(a, b) fn ext_gcd(a: usize, b: usize) -> (isize, isize, usize) { if a == 0 { return (0, 1, b); } let (x, y, g) = ext_gcd(b % a, a); (y - b as isize / a as isize * x, x, g) } fn mod_inv2(x: usize) -> usize { (ext_gcd(x, MOD).0 + MOD as isize) as usize % MOD }