#862083 (Rust) No.2277 Honest or Dishonest ?

• 問題: No.2277 Honest or Dishonest ?
• ユーザー: tipstar0125
• 提出日時: 2023-04-22 15:43:48
• 言語: Rust (1.77.0 + proconio)
• 結果: AC
• 実行時間: 76 ms / 2,000 ms
• コード長: 9,742 bytes
• コンパイル時間: 16,333 ms
• コンパイル使用メモリ: 378,744 KB
• 実行使用メモリ: 12,032 KB
• 最終ジャッジ日時: 2024-11-08 06:53:00
• 合計ジャッジ時間: 19,383 ms
• ジャッジサーバーID （参考情報）: judge4 / 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	56 ms; 8,960 KB
testcase_04	AC	61 ms; 10,624 KB
testcase_05	AC	25 ms; 6,912 KB
testcase_06	AC	45 ms; 7,296 KB
testcase_07	AC	36 ms; 6,912 KB
testcase_08	AC	20 ms; 6,528 KB
testcase_09	AC	38 ms; 8,320 KB
testcase_10	AC	26 ms; 5,504 KB
testcase_11	AC	11 ms; 5,248 KB
testcase_12	AC	20 ms; 5,248 KB
testcase_13	AC	53 ms; 8,320 KB
testcase_14	AC	24 ms; 5,504 KB
testcase_15	AC	20 ms; 6,016 KB
testcase_16	AC	37 ms; 6,656 KB
testcase_17	AC	17 ms; 5,248 KB
testcase_18	AC	57 ms; 10,368 KB
testcase_19	AC	57 ms; 10,240 KB
testcase_20	AC	42 ms; 8,320 KB
testcase_21	AC	34 ms; 6,272 KB
testcase_22	AC	35 ms; 7,296 KB
testcase_23	AC	48 ms; 7,552 KB
testcase_24	AC	31 ms; 7,040 KB
testcase_25	AC	45 ms; 9,472 KB
testcase_26	AC	12 ms; 5,376 KB
testcase_27	AC	22 ms; 5,248 KB
testcase_28	AC	19 ms; 6,016 KB
testcase_29	AC	34 ms; 7,680 KB
testcase_30	AC	21 ms; 5,248 KB
testcase_31	AC	40 ms; 7,296 KB
testcase_32	AC	29 ms; 7,296 KB
testcase_33	AC	55 ms; 9,856 KB
testcase_34	AC	62 ms; 9,344 KB
testcase_35	AC	8 ms; 5,248 KB
testcase_36	AC	35 ms; 6,656 KB
testcase_37	AC	54 ms; 8,064 KB
testcase_38	AC	10 ms; 5,248 KB
testcase_39	AC	15 ms; 5,248 KB
testcase_40	AC	8 ms; 5,248 KB
testcase_41	AC	65 ms; 9,856 KB
testcase_42	AC	42 ms; 7,808 KB
testcase_43	AC	75 ms; 11,904 KB
testcase_44	AC	74 ms; 11,904 KB
testcase_45	AC	75 ms; 11,904 KB
testcase_46	AC	74 ms; 11,904 KB
testcase_47	AC	73 ms; 11,904 KB
testcase_48	AC	74 ms; 11,904 KB
testcase_49	AC	76 ms; 11,904 KB
testcase_50	AC	73 ms; 11,904 KB
testcase_51	AC	71 ms; 11,904 KB
testcase_52	AC	73 ms; 12,032 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] as usize ^ c == 0 {
                            visited[next] = 0;
                        } else {
                            visited[next] = 1;
                        }
                        Q.push_back(next);
                    } else if visited[pos] as usize ^ c == 0 {
                        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
}