結果
| 問題 | No.287 場合の数 |
| ユーザー |
 Kohei Asano
|
| 提出日時 | 2020-01-14 18:21:43 |
| 言語 | Rust (1.77.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 10,552 bytes |
| コンパイル時間 | 1,627 ms |
| コンパイル使用メモリ | 163,332 KB |
| 実行使用メモリ | 136,808 KB |
| 最終ジャッジ日時 | 2023-08-26 22:10:27 |
| 合計ジャッジ時間 | 14,758 ms |
|
ジャッジサーバーID （参考情報） |
judge12 / judge15 |
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | TLE | - |
| testcase_01 | -- | - |
| testcase_02 | -- | - |
| testcase_03 | -- | - |
| testcase_04 | -- | - |
| testcase_05 | -- | - |
| testcase_06 | -- | - |
| testcase_07 | -- | - |
| testcase_08 | -- | - |
| testcase_09 | -- | - |
| testcase_10 | -- | - |
| testcase_11 | -- | - |
| testcase_12 | -- | - |
| testcase_13 | -- | - |
| testcase_14 | -- | - |
| testcase_15 | -- | - |
| testcase_16 | -- | - |
| testcase_17 | -- | - |
| testcase_18 | -- | - |
| testcase_19 | -- | - |
| testcase_20 | -- | - |
| testcase_21 | -- | - |
| testcase_22 | -- | - |
| testcase_23 | -- | - |
| testcase_24 | -- | - |
コンパイルメッセージ
warning: unused macro definition: `input`
--> Main.rs:1:14
|
1 | macro_rules! input {
| ^^^^^
|
= note: `#[warn(unused_macros)]` on by default
warning: unused macro definition: `input_inner`
--> Main.rs:17:14
|
17 | macro_rules! input_inner {
| ^^^^^^^^^^^
warning: unused macro definition: `read_value`
--> Main.rs:27:14
|
27 | macro_rules! read_value {
| ^^^^^^^^^^
warning: 3 warnings emitted
ソースコード
macro_rules! input {
(source = $s:expr, $($r:tt)*) => {
let mut iter = $s.split_whitespace();
input_inner!{iter, $($r)*}
};
($($r:tt)*) => {
let s = {
use std::io::Read;
let mut s = String::new();
std::io::stdin().read_to_string(&mut s).unwrap();
s
};
let mut iter = s.split_whitespace();
input_inner!{iter, $($r)*}
};
}
macro_rules! input_inner {
($iter:expr) => {};
($iter:expr, ) => {};
// var... 変数の識別子, $t...型を一つよむ
($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
let $var = read_value!($iter, $t);
//ここで繰り返し
input_inner!{$iter $($r)*}
};
}
macro_rules! read_value {
($iter:expr, ( $($t:tt),* )) => {
( $(read_value!($iter, $t)),* )
};
//
($iter:expr, [ $t:tt ; $len:expr ]) => {
(0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
};
($iter:expr, chars) => {
read_value!($iter, String).chars().collect::<Vec<char>>()
};
($iter:expr, usize1) => {
read_value!($iter, usize) - 1
};
// 配列の最後のNestではここで型が指定されてparseされる
($iter:expr, $t:ty) => {
$iter.next().unwrap().parse::<$t>().expect("Parse error")
};
}
macro_rules! input {
(source = $s:expr, $($r:tt)*) => {
let mut iter = $s.split_whitespace();
input_inner!{iter, $($r)*}
};
($($r:tt)*) => {
let s = {
use std::io::Read;
let mut s = String::new();
std::io::stdin().read_to_string(&mut s).unwrap();
s
};
let mut iter = s.split_whitespace();
input_inner!{iter, $($r)*}
};
}
macro_rules! input_inner {
($iter:expr) => {};
($iter:expr, ) => {};
// var... 変数の識別子, $t...型を一つよむ
($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
let $var = read_value!($iter, $t);
//ここで繰り返し
input_inner!{$iter $($r)*}
};
}
macro_rules! read_value {
($iter:expr, ( $($t:tt),* )) => {
( $(read_value!($iter, $t)),* )
};
//
($iter:expr, [ $t:tt ; $len:expr ]) => {
(0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
};
($iter:expr, chars) => {
read_value!($iter, String).chars().collect::<Vec<char>>()
};
($iter:expr, usize1) => {
read_value!($iter, usize) - 1
};
// 配列の最後のNestではここで型が指定されてparseされる
($iter:expr, $t:ty) => {
$iter.next().unwrap().parse::<$t>().expect("Parse error")
};
}
// =========
pub trait ModI:
Sized
+ PartialEq
+ Copy
+ std::ops::Add<Output = Self>
+ std::ops::Sub<Output = Self>
+ std::ops::Mul<Output = Self>
+ std::ops::Div<Output = Self>
+ std::ops::AddAssign
+ std::ops::SubAssign
+ std::ops::MulAssign
+ std::ops::DivAssign
+ std::default::Default
+ std::fmt::Display
+ std::fmt::Debug
{
fn m() -> u64;
fn new(x: u64) -> Self;
fn pow(self, n: u64) -> Self;
fn inv(&self) -> Self;
}
macro_rules! define_modint {
($n:ident,$m:expr) => {
#[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
struct $n(u64);
#[allow(dead_code)]
impl ModI for $n {
fn m() -> u64 {
$m
}
fn new(x: u64) -> $n {
$n(x % $m)
}
fn pow(self, mut n: u64) -> $n {
let mut ret = $n::new(1);
let mut base = self;
while n > 0 {
if n & 1 == 1 {
ret *= base;
}
base *= base;
n >>= 1;
}
ret
}
fn inv(&self) -> $n {
self.pow($m - 2)
}
}
impl std::default::Default for $n {
fn default() -> $n {
$n::new(0u64)
}
}
impl std::convert::From<u64> for $n {
fn from(x: u64) -> $n {
$n::new(x)
}
}
// Binary operator
impl std::ops::Add for $n {
type Output = $n;
fn add(self, rhs: $n) -> Self::Output {
$n::new(self.0 + rhs.0)
}
}
impl std::ops::Sub for $n {
type Output = $n;
fn sub(self, rhs: $n) -> Self::Output {
if self.0 >= rhs.0 {
$n::new(self.0 - rhs.0)
} else {
$n::new($m - rhs.0 + self.0)
}
}
}
impl std::ops::Mul for $n {
type Output = $n;
fn mul(self, rhs: $n) -> Self::Output {
$n::new(self.0 * rhs.0)
}
}
impl std::ops::Div for $n {
type Output = $n;
fn div(self, rhs: $n) -> Self::Output {
$n::new(self.0 / rhs.0)
}
}
// Assign
impl std::ops::AddAssign for $n {
fn add_assign(&mut self, rhs: $n) {
*self = *self + rhs;
}
}
impl std::ops::SubAssign for $n {
fn sub_assign(&mut self, rhs: $n) {
*self = *self - rhs;
}
}
impl std::ops::MulAssign for $n {
fn mul_assign(&mut self, rhs: $n) {
*self = *self * rhs;
}
}
impl std::ops::DivAssign for $n {
fn div_assign(&mut self, rhs: $n) {
*self = *self / rhs;
}
}
impl std::fmt::Display for $n {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl std::fmt::Debug for $n {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
};
}
// 10^8 < p < 10^9
// 3 is primitive p-1 root of these
// 167772161 = 5*2^25 + 1, 469762049 = 7*2^26 + 1, 998244353 = 119*2^23 + 1
// 1224736769 = 73 * 2^24 + 1
// define_modint!(ModInt167772161, 167772161);
define_modint!(ModInt998244353, 998244353);
define_modint!(ModInt1224736769, 1224736769);
fn ntt<T: ModI>(a: &mut [T], n: usize, inv: bool) {
// h = log2(n)
let h = {
let mut i = 0;
while 1 << i != n {
i += 1;
}
i
};
let mut j: usize;
for i in 0..n {
j = 0;
for k in 0..h {
// (i >> k & 1)はiのk桁目のbit
// (h - 1 - k)は全体をh-bitとしてk桁目の反対の位置
j |= (i >> k & 1) << (h - 1 - k);
}
// はじめの一回だけひっくりかえす
if i < j {
a.swap(i, j)
};
}
// バタフライ演算
let mut b = 1;
while b < n {
let zeta: T = T::new(3).pow((T::m() - 1) / (2 * b as u64));
for j in 0..b {
// 3 is primitive root of proth prime
// 3 ^ ((m - 1) / (n * j)) is primitive n root's j power
let e: T = if inv {
zeta.pow(j as u64).inv()
} else {
zeta.pow(j as u64)
};
let mut k = 0;
while k < n {
let s: T = a[j + k];
let t: T = a[j + k + b] * e;
a[j + k] = s + t;
a[j + k + b] = s - t;
k += b * 2;
}
}
b *= 2;
}
if inv {
let ni = T::new(n as u64).inv();
for i in 0..n {
a[i] *= ni;
}
}
}
fn mod_conv<T: ModI>(mut a: &mut [T], mut b: &mut [T]) -> Vec<T> {
let n = a.len();
// calc each mod
ntt(&mut a, n, false);
ntt(&mut b, n, false);
let mut c = Vec::with_capacity(n);
for i in 0..n {
c.push(a[i] * b[i]);
}
ntt(&mut c, n, true);
c
}
fn single_convolution<T: ModI>(a: &mut [T], b: &mut [T]) -> Vec<T> {
let d: usize = a.len() + b.len() - 1;
let n = d.checked_next_power_of_two().unwrap();
let mut a = a.to_vec();
a.resize(n, T::new(0));
let mut b = b.to_vec();
b.resize(n, T::new(0));
let mut res = mod_conv(&mut a, &mut b);
res.truncate(d);
res
}
fn mod_pow(mut a: u64, mut n: u64, m: u64) -> u64 {
let mut ret = 1;
while n > 0 {
if n & 1 == 1 {
ret *= a;
ret %= m;
}
a *= a;
a %= m;
n >>= 1;
}
ret
}
// mod mの体におけるaの逆元
fn mod_inv(a: u64, m: u64) -> u64 {
mod_pow(a, m - 2, m)
}
fn garner(mr: &mut Vec<(u64, u64)>, m: u64) -> u64 {
mr.push((m, 0));
// coef... mixed radixの係数, constants... 前まで求めた係数
let mut coef: Vec<u64> = vec![1; mr.len()];
let mut constants: Vec<u64> = vec![0; mr.len()];
for i in 0..mr.len() - 1 {
let v: u64 = (mr[i].1 + mr[i].0 - constants[i]) * mod_inv(coef[i], mr[i].0) % mr[i].0;
for j in i + 1..mr.len() {
constants[j] += coef[j] * v;
constants[j] %= mr[j].0;
coef[j] *= mr[i].0;
coef[j] %= mr[j].0;
}
}
constants[mr.len() - 1]
}
// for more bigger number
fn convolution(a: &[u64], b: &[u64]) -> Vec<u64> {
let d: usize = a.len() + b.len() - 1;
let n = d.checked_next_power_of_two().unwrap();
let mut a = a.to_vec();
a.resize(n, 0);
let mut b = b.to_vec();
b.resize(n, 0);
type F0 = ModInt1224736769;
type F1 = ModInt998244353;
let mut a0: Vec<F0> = a.iter().map(|e| F0::new(*e)).collect();
let mut b0: Vec<F0> = b.iter().map(|e| F0::new(*e)).collect();
let res0 = single_convolution(&mut a0, &mut b0);
let mut a1: Vec<F1> = a.iter().map(|e| F1::new(*e)).collect();
let mut b1: Vec<F1> = b.iter().map(|e| F1::new(*e)).collect();
let res1 = single_convolution(&mut a1, &mut b1);
let mut res: Vec<u64> = vec![];
for i in 0..res0.len() {
let mut mr = vec![(1224736769u64, res0[i].0), (998244353u64, res1[i].0)];
let v = garner(&mut mr, std::u64::MAX);
res.push(v);
}
res
}
fn main() {
input! {
n:usize,
}
let a: Vec<u64> = vec![1u64; n + 1];
let mut res = a.clone();
for _ in 0..7 {
res = convolution(&res, &a.clone());
}
println!("{:?}", res[6 * n]);
}