結果
| 問題 |
No.1142 XOR と XOR
|
| ユーザー |
 nebocco
|
| 提出日時 | 2021-02-12 20:24:29 |
| 言語 | Rust (1.83.0 + proconio) |
| 結果 |
AC
|
| 実行時間 | 14 ms / 2,000 ms |
| コード長 | 16,719 bytes |
| コンパイル時間 | 14,740 ms |
| コンパイル使用メモリ | 378,336 KB |
| 実行使用メモリ | 9,348 KB |
| 最終ジャッジ日時 | 2024-11-08 03:52:01 |
| 合計ジャッジ時間 | 16,399 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge3 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 25 |
ソースコード
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 ------------