結果
| 問題 | No.2489 X and Xor 2 |
| ユーザー |
 koba-e964
|
| 提出日時 | 2023-12-19 02:29:35 |
| 言語 | Rust (1.77.0 + proconio) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 7,546 bytes |
| コンパイル時間 | 14,109 ms |
| コンパイル使用メモリ | 382,532 KB |
| 実行使用メモリ | 6,948 KB |
| 最終ジャッジ日時 | 2024-09-27 08:35:59 |
| 合計ジャッジ時間 | 14,819 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge5 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | WA | - |
| testcase_01 | WA | - |
| testcase_02 | WA | - |
| testcase_03 | WA | - |
| testcase_04 | WA | - |
| testcase_05 | WA | - |
| testcase_06 | WA | - |
| testcase_07 | WA | - |
| testcase_08 | WA | - |
| testcase_09 | WA | - |
| testcase_10 | WA | - |
| testcase_11 | WA | - |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | WA | - |
| testcase_15 | WA | - |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | WA | - |
| testcase_20 | WA | - |
| testcase_21 | WA | - |
| testcase_22 | WA | - |
| testcase_23 | WA | - |
| testcase_24 | WA | - |
| testcase_25 | WA | - |
| testcase_26 | WA | - |
| testcase_27 | WA | - |
| testcase_28 | WA | - |
| testcase_29 | WA | - |
| testcase_30 | WA | - |
| testcase_31 | WA | - |
| testcase_32 | WA | - |
| testcase_33 | WA | - |
| testcase_34 | WA | - |
| testcase_35 | WA | - |
| testcase_36 | WA | - |
コンパイルメッセージ
warning: unused variable: `n`
--> src/main.rs:181:9
|
181 | let n: i64 = get();
| ^ help: if this is intentional, prefix it with an underscore: `_n`
|
= note: `#[warn(unused_variables)]` on by default
warning: unused variable: `i`
--> src/main.rs:203:13
|
203 | for i in 0..k {
| ^ help: if this is intentional, prefix it with an underscore: `_i`
ソースコード
#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;
use std::io::Read;
fn get_word() -> String {
let stdin = std::io::stdin();
let mut stdin=stdin.lock();
let mut u8b: [u8; 1] = [0];
loop {
let mut buf: Vec<u8> = Vec::with_capacity(16);
loop {
let res = stdin.read(&mut u8b);
if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {
break;
} else {
buf.push(u8b[0]);
}
}
if buf.len() >= 1 {
let ret = String::from_utf8(buf).unwrap();
return ret;
}
}
}
fn get<T: std::str::FromStr>() -> T { get_word().parse().ok().unwrap() }
/// Verified by https://atcoder.jp/contests/abc198/submissions/21774342
mod mod_int {
use std::ops::*;
pub trait Mod: Copy { fn m() -> i64; }
#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct ModInt<M> { pub x: i64, phantom: ::std::marker::PhantomData<M> }
impl<M: Mod> ModInt<M> {
// x >= 0
pub fn new(x: i64) -> Self { ModInt::new_internal(x % M::m()) }
fn new_internal(x: i64) -> Self {
ModInt { x: x, phantom: ::std::marker::PhantomData }
}
pub fn pow(self, mut e: i64) -> Self {
debug_assert!(e >= 0);
let mut sum = ModInt::new_internal(1);
let mut cur = self;
while e > 0 {
if e % 2 != 0 { sum *= cur; }
cur *= cur;
e /= 2;
}
sum
}
#[allow(dead_code)]
pub fn inv(self) -> Self { self.pow(M::m() - 2) }
}
impl<M: Mod> Default for ModInt<M> {
fn default() -> Self { Self::new_internal(0) }
}
impl<M: Mod, T: Into<ModInt<M>>> Add<T> for ModInt<M> {
type Output = Self;
fn add(self, other: T) -> Self {
let other = other.into();
let mut sum = self.x + other.x;
if sum >= M::m() { sum -= M::m(); }
ModInt::new_internal(sum)
}
}
impl<M: Mod, T: Into<ModInt<M>>> Sub<T> for ModInt<M> {
type Output = Self;
fn sub(self, other: T) -> Self {
let other = other.into();
let mut sum = self.x - other.x;
if sum < 0 { sum += M::m(); }
ModInt::new_internal(sum)
}
}
impl<M: Mod, T: Into<ModInt<M>>> Mul<T> for ModInt<M> {
type Output = Self;
fn mul(self, other: T) -> Self { ModInt::new(self.x * other.into().x % M::m()) }
}
impl<M: Mod, T: Into<ModInt<M>>> AddAssign<T> for ModInt<M> {
fn add_assign(&mut self, other: T) { *self = *self + other; }
}
impl<M: Mod, T: Into<ModInt<M>>> SubAssign<T> for ModInt<M> {
fn sub_assign(&mut self, other: T) { *self = *self - other; }
}
impl<M: Mod, T: Into<ModInt<M>>> MulAssign<T> for ModInt<M> {
fn mul_assign(&mut self, other: T) { *self = *self * other; }
}
impl<M: Mod> Neg for ModInt<M> {
type Output = Self;
fn neg(self) -> Self { ModInt::new(0) - self }
}
impl<M> ::std::fmt::Display for ModInt<M> {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
self.x.fmt(f)
}
}
impl<M: Mod> ::std::fmt::Debug for ModInt<M> {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let (mut a, mut b, _) = red(self.x, M::m());
if b < 0 {
a = -a;
b = -b;
}
write!(f, "{}/{}", a, b)
}
}
impl<M: Mod> From<i64> for ModInt<M> {
fn from(x: i64) -> Self { Self::new(x) }
}
// Finds the simplest fraction x/y congruent to r mod p.
// The return value (x, y, z) satisfies x = y * r + z * p.
fn red(r: i64, p: i64) -> (i64, i64, i64) {
if r.abs() <= 10000 {
return (r, 1, 0);
}
let mut nxt_r = p % r;
let mut q = p / r;
if 2 * nxt_r >= r {
nxt_r -= r;
q += 1;
}
if 2 * nxt_r <= -r {
nxt_r += r;
q -= 1;
}
let (x, z, y) = red(nxt_r, r);
(x, y - q * z, z)
}
} // mod mod_int
macro_rules! define_mod {
($struct_name: ident, $modulo: expr) => {
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct $struct_name {}
impl mod_int::Mod for $struct_name { fn m() -> i64 { $modulo } }
}
}
const MOD: i64 = 998_244_353;
define_mod!(P, MOD);
type MInt = mod_int::ModInt<P>;
// #{x | x < m, (x as bitstring)[p] = 1}
fn count_pop_bits(m: i64, p: usize) -> i64 {
let lead = m & ((-1) << (p + 1));
let rest = m - (lead << (p + 1));
(lead >> 1) + if rest >= 1 << p { rest - (1 << p) } else { 0 }
}
fn e(m: i64, p: usize) -> MInt {
let lead = m & ((-1) << (p + 1));
let rest = m - (lead << (p + 1));
let p2 = MInt::new(1 << p);
let inv2 = MInt::new(2).inv();
let count = MInt::new(lead >> (p + 1));
let mut tot = p2 * (p2 * 3 - 1) * inv2 * count;
tot += count * (count - 1) * inv2 * MInt::new(1 << (p + 1));
if rest >= 1 << p {
tot += MInt::new(lead + (1 << p)) * (rest - (1 << p));
let tmp = MInt::new(rest - (1 << p));
tot += tmp * (tmp - 1) * inv2;
}
tot
}
// dp[i][j] := i 番目まで埋めて A_i= j のときの積の総和 とすると、dp[i] |-> dp[i+1] は線型変換。
// これを行列累乗する必要があるが、そのままだと次元が M であり大きすぎるのである程度まとめる必要がある。
// u_j = dp[i][j], v_j = dp[i+1][j] として、u から v を作る線型変換のより小さい不変部分空間を作る。
// v_j = \sum_k u_k (k xor j) である。
// a := (u_j の和), s_i := {i 番目ビットが立っているもの限定の u_j の和},
// b := (v_j の和), t_i := {i 番目ビットが立っているもの限定の v_j の和} とする。
// a, s_i から b, t_i が計算できるのがポイント。そのためには以下の補題を使う。
// 補題: k = 2^a + 2^b + ... とする。このとき (k xor j) - j = ((2^a xor j) - j) + ((2^b xor j) - j) + ...
// この補題を使うと、まず b = (M(M-1)/2) a + \sum c(2^i) s_i が言える。(c(x) := \sum_{j<M} ((x xor j) - j))
// 同様に t_j := \sum_{k<M, k の j ビット目は立っている} ka + \sum_i d(2^i) s_i
// (d_j(x) := \sum_{k<M, k の j ビット目は立っている} ((x xor k) - k)) が言える。
// (証明の方針: b - (M(M-1)/2) a = \sum_{j,k} u_k ((k xor j) - j) = \sum c(2^i) \sum_{k<n, k の i ビット目は立っている} u_k = \sum c(2^i) s_i)
// c(2^i), d_j(2^i), e_j := \sum_{k<M, k の j ビット目は立っている} k は高速に計算できる。
fn main() {
let n: i64 = get();
let m: i64 = get();
let mut k = 0;
while (1 << k) < m {
k += 1;
}
let mut init = vec![MInt::new(0); k + 1];
init[0] += m;
for i in 0..k {
init[i + 1] += count_pop_bits(m, i);
}
let mut pred = vec![MInt::new(0); k + 1];
pred[0] += 1;
let mut mat = vec![vec![MInt::new(0); k + 1]; k + 1];
let mm = m % MOD;
mat[0][0] += mm * (mm - 1) / 2;
for i in 0..k {
let tmp = MInt::new(m) - count_pop_bits(m, i) * 2;
mat[i + 1][0] += tmp * MInt::new(2).pow(i as i64);
}
for j in 0..k {
mat[0][j + 1] = e(m, j);
for i in 0..k {
}
}
eprintln!("mat = {:?}", mat);
}