結果

問題 No.1142 XOR と XOR
ユーザー nebocconebocco
提出日時 2021-02-12 20:24:29
言語 Rust
(1.77.0)
結果
AC  
実行時間 14 ms / 2,000 ms
コード長 16,719 bytes
コンパイル時間 1,784 ms
コンパイル使用メモリ 194,576 KB
実行使用メモリ 9,476 KB
最終ジャッジ日時 2024-04-25 16:45:05
合計ジャッジ時間 3,067 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,812 KB
testcase_01 AC 1 ms
6,812 KB
testcase_02 AC 1 ms
6,816 KB
testcase_03 AC 14 ms
9,476 KB
testcase_04 AC 8 ms
6,948 KB
testcase_05 AC 8 ms
6,940 KB
testcase_06 AC 11 ms
8,108 KB
testcase_07 AC 10 ms
8,308 KB
testcase_08 AC 12 ms
8,924 KB
testcase_09 AC 11 ms
9,176 KB
testcase_10 AC 12 ms
9,052 KB
testcase_11 AC 1 ms
6,940 KB
testcase_12 AC 1 ms
6,944 KB
testcase_13 AC 1 ms
6,940 KB
testcase_14 AC 7 ms
6,940 KB
testcase_15 AC 6 ms
6,940 KB
testcase_16 AC 1 ms
6,940 KB
testcase_17 AC 8 ms
6,944 KB
testcase_18 AC 3 ms
6,940 KB
testcase_19 AC 10 ms
7,980 KB
testcase_20 AC 7 ms
6,944 KB
testcase_21 AC 5 ms
6,940 KB
testcase_22 AC 2 ms
6,940 KB
testcase_23 AC 10 ms
7,672 KB
testcase_24 AC 10 ms
8,252 KB
testcase_25 AC 6 ms
6,940 KB
testcase_26 AC 10 ms
7,796 KB
testcase_27 AC 8 ms
6,940 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

fn main() {
	type Fp = F1000000007;
	let mut io = IO::new();
	let (n, m, k): (usize, usize, usize) = io.scan();
	let a = std::iter::once(0)
	.chain(io.scan_vec::<usize>(n).into_iter())
	.scan(0, |sum, x| { *sum ^= x; Some(*sum) })
	.collect::<Vec<usize>>();
	let b = std::iter::once(0)
	.chain(io.scan_vec::<usize>(m).into_iter())
	.scan(0, |sum, x| { *sum ^= x; Some(*sum) })
	.collect::<Vec<usize>>();
	// println!("{:?}", &a);
	let mut ad = vec![Fp::zero(); 1024];
	let mut bd = vec![Fp::zero(); 1024];
	for &x in &a {
		ad[x] += Fp::one();
	}
	for &x in &b {
		bd[x] += Fp::one();
	}
	// println!("{:?}", &ad[..4]);
	let mut aa = xor_convolution(&ad, &ad);
	let mut bb = xor_convolution(&bd, &bd);
	// println!("{:?}", &aa[..4]);

	let inv2 = Fp::new(2).inv();
	let inv1024 = Fp::new(1024).inv();
	aa.iter_mut().for_each(|x| *x *= inv1024);
	bb.iter_mut().for_each(|x| *x *= inv1024);
	aa[0] -= Fp::new(n as i64 + 1);
	bb[0] -= Fp::new(m as i64 + 1);
	aa.iter_mut().for_each(|x| *x *= inv2);
	bb.iter_mut().for_each(|x| *x *= inv2);

	// println!("{:?}", &aa[..4]);

	let ans = (0..1024).map(|i| aa[i] * bb[i^k]).sum::<Fp>();
	io.println(ans.into_inner());
}

// ------------ zeta & mobius start ------------

macro_rules! define_transform {
	($trait: ident, $name: ident, $expr: expr) => {
		pub fn $name<T: Copy + $trait>(f: &mut [T]) {
			assert!(f.len().is_power_of_two(),
			"length should be power of two.");
			for h in (0..f.len().trailing_zeros()).map(|i| 1 << i) {
				for chunk in f.chunks_mut(2 * h) {
					let (fst, snd) = chunk.split_at_mut(h);
					fst.iter_mut().zip(snd).for_each($expr);
				}
			}
		}
	};
}

macro_rules! define_convolution {
	($trait: ident, $name: ident, $transform: tt, $inverse_transform: tt) => {
		pub fn $name<T: Copy + $trait>(f: &[T], g: &[T]) -> Vec<T> {
			assert_eq!(f.len(), g.len(),
			"Vectors should have same length");
			let mut f = f.to_vec();
			let mut g = g.to_vec();
			$transform(&mut f);
			$transform(&mut g);
			f.iter_mut().zip(g).for_each(|(a, b)| *a = *a * b);
			$inverse_transform(&mut f);
			f
		}
	};
}

// Walsh transform.
define_transform!(Group, walsh_transform, |(x, y)| {
	let (u, v) = (*x, *y);
	*x = u + v;
	*y = u + -v;
});
// Arithmetic Transform (Plus), a.k.a., the Mobius transform.
define_transform!(ComGroup, subset_zeta, |(x, y)| *y += *x);

// Arithmetic Transform (Minus), a.k.a., the Inverse Mobius transform.
define_transform!(ComGroup, subset_mobius, |(x, y)| *y += -*x);

// Arithmetic Transform (Plus), a.k.a., the Mobius transform.
define_transform!(ComGroup, superset_zeta, |(x, y)| *x += *y);

// Arithmetic Transform (Minus), a.k.a., the Inverse Mobius transform.
define_transform!(ComGroup, superset_mobius, |(x, y)| *x += -*y);

// Or-convolution (a.k.a. Covering product)
// h[X] = \sum_{S, T: S \cup T = X} f[S] g[T].
define_convolution!(Ring, or_convolution, subset_zeta, subset_mobius);

// And-convolution (a.k.a. Packing product)
// h[X] = \sum_{S, T: S \cap T = X} f[S] g[T].
define_convolution!(Ring, and_convolution, superset_zeta, superset_mobius);

// Xor-convolution
// h[X] = n * \sum_{S, T: T xor S = X} f[S] g[T].
define_convolution!(Field, xor_convolution, walsh_transform, walsh_transform);


/// c[v] = sum _ {i|j = v, i&j = 0} a[i] * b[j];
pub fn subset_convolution<R: Ring + Copy>(a: &[R], b: &[R]) -> Vec<R> {
	assert_eq!(a.len(), b.len(), "given 2 Vecs have different length");
	assert!(a.len().is_power_of_two(), "length of Vec should be power of 2");
	let n = a.len();
    let m = n.trailing_zeros() as usize;
    let mut pct = vec![Vec::new(); m+1];
    (0..n).for_each(|i| { pct[i.count_ones() as usize].push(i); });
	let mut f = vec![vec![R::zero(); n]; m+1];
	let mut g = vec![vec![R::zero(); n]; m+1];
	for (k, list) in pct.iter().enumerate() {
        list.iter().for_each(|&i| {
            f[k][i] = a[i];
            g[k][i] = b[i];
        });
	}
	f.iter_mut().for_each(|h| { subset_zeta(h); });
	g.iter_mut().for_each(|h| { subset_zeta(h); });
	let mut res = vec![R::zero(); n];
	for (k, list) in pct.iter().enumerate() {
        let mut h = vec![R::zero(); n];
		for j in 0..=k {
            h.iter_mut()
                .zip(f[j].iter().zip(g[k-j].iter()))
                .for_each(|(z, (x, y))| { *z += *x * *y; });
        }
        subset_mobius(&mut h);
        list.iter().for_each(|&i| { res[i] = h[i]; });
	}
    res
}

// ------------ zeta & mobius end ------------

// ------------ fp start ------------

use std::{
    fmt::{Debug, Display},
    hash::Hash,
    iter,
    marker::PhantomData,
};

// NOTE: `crate::` がないとうまく展開できません。
crate::define_fp!(pub F998244353, Mod998244353, 998244353);
crate::define_fp!(pub F1000000007, Mod1000000007, 1000000007);

#[derive(Clone, PartialEq, Copy, Eq, Hash)]
pub struct Fp<T>(i64, PhantomData<T>);
pub trait Mod: Debug + Clone + PartialEq + Copy + Eq + Hash {
    const MOD: i64;
}
impl<T: Mod> Fp<T> {
    pub fn new(mut x: i64) -> Self {
        x %= T::MOD;
        Self::unchecked(if x < 0 { x + T::MOD } else { x })
    }
    pub fn into_inner(self) -> i64 {
        self.0
    }
    pub fn r#mod() -> i64 {
        T::MOD
    }
    pub fn inv(self) -> Self {
        assert_ne!(self.0, 0, "Zero division");
        let (sign, x) = if self.0 * 2 < T::MOD {
            (1, self.0)
        } else {
            (-1, T::MOD - self.0)
        };
        let (g, _a, b) = ext_gcd(T::MOD, x);
        let ans = sign * b;
        assert_eq!(g, 1);
        Self::unchecked(if ans < 0 { ans + T::MOD } else { ans })
    }
    pub fn frac(x: i64, y: i64) -> Self {
        Fp::new(x) / Fp::new(y)
    }
    pub fn pow(mut self, mut p: u64) -> Self {
        let mut ans = Fp::new(1);
        while p != 0 {
            if p & 1 == 1 {
                ans *= self;
            }
            self *= self;
            p >>= 1;
        }
        ans
    }
    fn unchecked(x: i64) -> Self {
        Self(x, PhantomData)
    }
}
impl<T: Mod> iter::Sum<Fp<T>> for Fp<T> {
    fn sum<I>(iter: I) -> Self
    where
        I: iter::Iterator<Item = Fp<T>>,
    {
        iter.fold(Fp::new(0), Add::add)
    }
}

impl<'a, T: 'a + Mod> iter::Sum<&'a Fp<T>> for Fp<T> {
    fn sum<I>(iter: I) -> Self
    where
        I: iter::Iterator<Item = &'a Fp<T>>,
    {
        iter.fold(Fp::new(0), Add::add)
    }
}

impl<T: Mod> iter::Product<Fp<T>> for Fp<T> {
    fn product<I>(iter: I) -> Self
    where
        I: iter::Iterator<Item = Fp<T>>,
    {
        iter.fold(Self::new(1), Mul::mul)
    }
}

impl<'a, T: 'a + Mod> iter::Product<&'a Fp<T>> for Fp<T> {
    fn product<I>(iter: I) -> Self
    where
        I: iter::Iterator<Item = &'a Fp<T>>,
    {
        iter.fold(Self::new(1), Mul::mul)
    }
}
impl<T: Mod> Debug for Fp<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(f, "{}", self.0)
    }
}
impl<T: Mod> Display for Fp<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(f, "{}", self.0)
    }
}

// ax + by = gcd(x, y) なる、互いに素な (a, b) を一組探して、(g, a, b) を返します。
//
// | 0  -x |   | y  -x | | x  0 |
// | 1   b | = | a   b | | y  1 |
fn ext_gcd(x: i64, y: i64) -> (i64, i64, i64) {
    let (b, g) = {
        let mut x = x;
        let mut y = y;
        let mut u = 0;
        let mut v = 1;
        while x != 0 {
            let q = y / x;
            y -= q * x;
            v -= q * u;
            std::mem::swap(&mut x, &mut y);
            std::mem::swap(&mut u, &mut v);
        }
        (v, y)
    };
    assert_eq!((g - b * y) % x, 0);
    let a = (g - b * y) / x;
    (g, a, b)
}

#[macro_export]
macro_rules! define_fp {
    ($vis:vis $fp:ident, $t:ident, $mod:expr) => {
        #[derive(Debug, Clone, PartialEq, Copy, Eq, Hash)]
        $vis struct $t;
        // NOTE: `$crate::` があるとうまく展開できません。
        impl Mod for $t {
            const MOD: i64 = $mod;
        }
        // NOTE: `$crate::` があるとうまく展開できません。
        $vis type $fp = Fp<$t>;
    }
}

// ------------ impl arith start ------------

impl<T: Mod> Associative for Fp<T> {}

impl<T: Mod> Zero for Fp<T> {
    fn zero() -> Self { Self::unchecked(0) }
    fn is_zero(&self) -> bool { self.0 == 0 }
}

impl<T: Mod> One for Fp<T> {
    fn one() -> Self { Self::unchecked(1) }
    fn is_one(&self) -> bool { self.0 == 1 }
}

impl<T: Mod> Add for Fp<T> {
    type Output = Self;
    fn add(self, rhs: Self) -> Self {
        let res = self.0 + rhs.0;
        Self::unchecked(if T::MOD <= res { res - T::MOD } else { res })
    }
}

impl<T: Mod> Sub for Fp<T> {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self {
        let res = self.0 - rhs.0;
        Self::unchecked(if res < 0 { res + T::MOD } else { res })
    }
}

impl<T: Mod> Mul for Fp<T> {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self {
        Self::new(self.0 * rhs.0)
    }
}

#[allow(clippy::suspicious_arithmetic_impl)]
impl<T: Mod> Div for Fp<T> {
    type Output = Self;
    fn div(self, rhs: Self) -> Self {
        self * rhs.inv()
    }
}

impl<M: Mod> Neg for Fp<M> {
    type Output = Self;
    fn neg(self) -> Self {
        if self.0 == 0 {
            Self::unchecked(0)
        } else {
            Self::unchecked(M::MOD - self.0)
        }
    }
}

impl<M: Mod> Neg for &Fp<M> {
    type Output = Fp<M>;
    fn neg(self) -> Self::Output {
        if self.0 == 0 {
            Fp::unchecked(0)
        } else {
            Fp::unchecked(M::MOD - self.0)
        }
    }
}

macro_rules! forward_assign_biop {
    ($(impl $trait:ident, $fn_assign:ident, $fn:ident)*) => {
        $(
            impl<M: Mod> $trait for Fp<M> {
                fn $fn_assign(&mut self, rhs: Self) {
                    *self = self.$fn(rhs);
                }
            }
        )*
    };
}

forward_assign_biop! {
    impl AddAssign, add_assign, add
    impl SubAssign, sub_assign, sub
    impl MulAssign, mul_assign, mul
    impl DivAssign, div_assign, div
}

macro_rules! forward_ref_binop {
    ($(impl $imp:ident, $method:ident)*) => {
        $(
            impl<'a, T: Mod> $imp<Fp<T>> for &'a Fp<T> {
                type Output = Fp<T>;
                fn $method(self, other: Fp<T>) -> Self::Output {
                    $imp::$method(*self, other)
                }
            }

            impl<'a, T: Mod> $imp<&'a Fp<T>> for Fp<T> {
                type Output = Fp<T>;
                fn $method(self, other: &Fp<T>) -> Self::Output {
                    $imp::$method(self, *other)
                }
            }

            impl<'a, T: Mod> $imp<&'a Fp<T>> for &'a Fp<T> {
                type Output = Fp<T>;
                fn $method(self, other: &Fp<T>) -> Self::Output {
                    $imp::$method(*self, *other)
                }
            }
        )*
    };
}

forward_ref_binop! {
    impl Add, add
    impl Sub, sub
    impl Mul, mul
    impl Div, div
}


// ------------ impl arith end ------------

// ------------ fp end ------------

// ------------ algebraic traits start ------------
use std::marker::Sized;
use std::ops::*;

/// 元
pub trait Element: Sized + Clone + PartialEq {}
impl<T: Sized + Clone + PartialEq> Element for T {}

/// 結合性
pub trait Associative: Magma {}

/// マグマ
pub trait Magma: Element + Add<Output=Self> {}
impl<T: Element + Add<Output=Self>> Magma for T {}

/// 半群
pub trait SemiGroup: Magma + Associative {}
impl<T: Magma + Associative> SemiGroup for T {}

/// モノイド
pub trait Monoid: SemiGroup + Zero {}
impl<T: SemiGroup + Zero> Monoid for T {}

pub trait ComMonoid: Monoid + AddAssign {}
impl<T: Monoid + AddAssign> ComMonoid for T {}

/// 群
pub trait Group: Monoid + Neg<Output=Self> {}
impl<T: Monoid + Neg<Output=Self>> Group for T {}

pub trait ComGroup: Group + ComMonoid {}
impl<T: Group + ComMonoid> ComGroup for T {}

/// 半環
pub trait SemiRing: ComMonoid + Mul<Output=Self> + One {}
impl<T: ComMonoid + Mul<Output=Self> + One> SemiRing for T {}

/// 環
pub trait Ring: ComGroup + SemiRing {}
impl<T: ComGroup + SemiRing> Ring for T {}

pub trait ComRing: Ring + MulAssign {}
impl<T: Ring + MulAssign> ComRing for T {}

/// 体
pub trait Field: ComRing + Div<Output=Self> + DivAssign {}
impl<T: ComRing + Div<Output=Self> + DivAssign> Field for T {}

/// 加法単元
pub trait Zero: Element {
    fn zero() -> Self;
    fn is_zero(&self) -> bool {
        *self == Self::zero()
    }
}

/// 乗法単元
pub trait One: Element {
    fn one() -> Self;
    fn is_one(&self) -> bool {
        *self == Self::one()
    }
}

macro_rules! impl_integer {
    ($($T:ty,)*) => {
        $(
            impl Associative for $T {}

            impl Zero for $T {
                fn zero() -> Self { 0 }
                fn is_zero(&self) -> bool { *self == 0 }
            }

            impl<'a> Zero for &'a $T {
                fn zero() -> Self { &0 }
                fn is_zero(&self) -> bool { *self == &0 }
            }

            impl One for $T {
                fn one() -> Self { 1 }
                fn is_one(&self) -> bool { *self == 1 }
            }

            impl<'a> One for &'a $T {
                fn one() -> Self { &1 }
                fn is_one(&self) -> bool { *self == &1 }
            }
        )*
    };
}

impl_integer! {
    i8, i16, i32, i64, i128, isize,
    u8, u16, u32, u64, u128, usize,
}
// ------------ algebraic traits end ------------

// ------------ io module start ------------

use std::io::{stdout, BufWriter, Read, StdoutLock, Write};

pub struct IO {
	iter: std::str::SplitAsciiWhitespace<'static>,
	buf: BufWriter<StdoutLock<'static>>,
}

impl IO {
	pub fn new() -> Self {
		let mut input = String::new();
		std::io::stdin().read_to_string(&mut input).unwrap();
		let input = Box::leak(input.into_boxed_str());
		let out = Box::new(stdout());
		IO {
			iter: input.split_ascii_whitespace(),
			buf: BufWriter::new(Box::leak(out).lock()),
		}
	}
	fn scan_str(&mut self) -> &'static str {
		self.iter.next().unwrap()
	}
	fn scan_raw(&mut self) -> &'static [u8] {
		self.scan_str().as_bytes()
	}
	pub fn scan<T: Scan>(&mut self) -> T {
		T::scan(self)
	}
	pub fn scan_vec<T: Scan>(&mut self, n: usize) -> Vec<T> {
		(0..n).map(|_| self.scan()).collect()
	}
}

impl IO {
	pub fn print<T: Print>(&mut self, x: T) {
		T::print(self, x);
	}
	pub fn println<T: Print>(&mut self, x: T) {
		self.print(x);
		self.print("\n");
	}
	pub fn iterln<T: Print, I: Iterator<Item = T>>(&mut self, mut iter: I, delim: &str) {
		if let Some(v) = iter.next() {
			self.print(v);
			for v in iter {
				self.print(delim);
				self.print(v);
			}
		}
		self.print("\n");
	}
	pub fn flush(&mut self) {
		self.buf.flush().unwrap();
	}
}

impl Default for IO {
	fn default() -> Self {
		Self::new()
	}
}

pub trait Scan {
	fn scan(io: &mut IO) -> Self;
}

macro_rules! impl_parse_int {
	($($t:tt),*) => {
		$(
			impl Scan for $t {
				fn scan(s: &mut IO) -> Self {
					let mut res = 0;
					let mut neg = false;
					for d in s.scan_raw() {
						if *d == b'-' {
							neg = true;
						} else {
							res *= 10;
							res += (*d - b'0') as $t;
						}
					}
					if neg { res = res.wrapping_neg(); }
					res
				}
			}
		)*
	};
}

impl_parse_int!(i16, i32, i64, isize, u16, u32, u64, usize);

impl<T: Scan, U: Scan> Scan for (T, U) {
	fn scan(s: &mut IO) -> Self {
		(T::scan(s), U::scan(s))
	}
}

impl<T: Scan, U: Scan, V: Scan> Scan for (T, U, V) {
	fn scan(s: &mut IO) -> Self {
		(T::scan(s), U::scan(s), V::scan(s))
	}
}

impl<T: Scan, U: Scan, V: Scan, W: Scan> Scan for (T, U, V, W) {
	fn scan(s: &mut IO) -> Self {
		(T::scan(s), U::scan(s), V::scan(s), W::scan(s))
	}
}

pub trait Print {
	fn print(w: &mut IO, x: Self);
}

macro_rules! impl_print_int {
	($($t:ty),*) => {
		$(
			impl Print for $t {
				fn print(w: &mut IO, x: Self) {
					w.buf.write_all(x.to_string().as_bytes()).unwrap();
				}
			}
		)*
	};
}

impl_print_int!(i16, i32, i64, isize, u16, u32, u64, usize);

impl Print for u8 {
	fn print(w: &mut IO, x: Self) {
		w.buf.write_all(&[x]).unwrap();
	}
}

impl Print for &[u8] {
	fn print(w: &mut IO, x: Self) {
		w.buf.write_all(x).unwrap();
	}
}

impl Print for &str {
	fn print(w: &mut IO, x: Self) {
		w.print(x.as_bytes());
	}
}

impl Print for String {
	fn print(w: &mut IO, x: Self) {
		w.print(x.as_bytes());
	}
}

impl<T: Print, U: Print> Print for (T, U) {
	fn print(w: &mut IO, (x, y): Self) {
		w.print(x);
		w.print(" ");
		w.print(y);
	}
}

impl<T: Print, U: Print, V: Print> Print for (T, U, V) {
	fn print(w: &mut IO, (x, y, z): Self) {
		w.print(x);
		w.print(" ");
		w.print(y);
		w.print(" ");
		w.print(z);
	}
}

// ------------ io module end ------------
0