Submission #1863842


Source Code Expand

#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, BinaryHeap, VecDeque, BTreeSet, BTreeMap};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::io::stdin;

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
}

#[allow(unused_macros)]
macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
                    get!($t)
                   ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
                    get!($($t),*)
                   ).collect::<Vec<_>>()
    };
    ($t:ty ;;) => {
        {
            let mut line: String = String::new();
            stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|t| t.parse::<$t>().unwrap())
                .collect::<Vec<_>>()
        }
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn gcd(a: u64, b: u64) -> u64 {
    if b == 0 { a } else { gcd(b, a % b) }
}


fn lcm(a: u64, b: u64) -> u64 {
    a / gcd(a, b) * b
}

// (gcd, x, y)
fn extgcd(a: i64, b: i64) -> (i64, i64, i64) {
    if b == 0 {
        (a, 1, 0)
    } else {
        let (gcd, x, y) = extgcd(b, a % b);
        (gcd, y, x - (a / b) * y)
    }
}

fn mod_pow(x: u64, n: u64, m: u64) -> u64 {
    let mut res = 1;
    let mut x = x;
    let mut n = n;
    while n > 0 {
        if n & 1 == 1 {
            res = (res * x) % m;
        }
        x = (x * x) % m;
        n = n >> 1;
    }
    res
}

fn mod_inverse(a: u64, m: u64) -> u64 {
    let (_, x, _) = extgcd(a as i64, m as i64);
    ((m as i64 + x) as u64 % m) % m
}

fn fact_table(len: usize, m: u64) -> Vec<u64> {
    let mut res = vec![1; len];
    for i in 1..len {
        res[i] = (i as u64 * res[i - 1]) % m;
    }
    res
}


// (a mod p, e when n! = a p^e)
fn mod_fact(n: u64, p: u64, fact: &Vec<u64>) -> (u64, u64) {
    if n == 0 {
        (1, 0)
    } else {
        let (a, b) = mod_fact(n / p, p, fact);
        let e = b + n / p;

        if n / p % 2 != 0 {
            (a * (p - fact[(n % p) as usize]) % p, e)
        } else {
            (a * fact[(n % p) as usize] % p, e)
        }
    }
}

fn mod_comb(n: u64, k: u64, p: u64, fact: &Vec<u64>) -> u64 {
    if n < k {
        0
    } else {
        let (a1, e1) = mod_fact(n, p, fact);
        let (a2, e2) = mod_fact(k, p, fact);
        let (a3, e3) = mod_fact(n - k, p, fact);

        if e1 > e2 + e3 {
            0
        } else {
            a1 * mod_inverse(a2 * a3 % p, p) % p
        }
    }
}

const M: u64 = 1000000007;

fn main() {
    let (n, a, b, c, d) = get!(usize, usize, usize, usize, usize);

    let fact = fact_table(n + 1, M);

    let mut dp = vec![0; n + 1];
    dp[n] = 1;

    for i in a..b + 1 {
        let mut next = dp.clone();
        if i * c > n {
            break;
        }

        for k in i * c..n + 1 {
            let mut m = c;
            while k >= m * i && m <= d && (k - m * i >= (i + 1) * c || k % i == 0) {
                if dp[k] > 0 && (k - m * i >= (i + 1) * c || k - m * i == 0) {
                    let delta = dp[k] * fact[k] % M;
                    let mut inv = fact[k - m * i] * mod_pow(fact[i], m as u64, M) % M;
                    inv = inv * fact[m];
                    next[k - m * i] += delta * mod_inverse(inv, M) % M;
                    next[k - m * i] %= M;
                }
                m += 1;
            }

        }
        dp = next;
    }

    println!("{}", dp[0]);
}

Submission Info

Submission Time
Task E - Grouping
User hatoo
Language Rust (1.15.1)
Score 600
Code Size 4835 Byte
Status AC
Exec Time 786 ms
Memory 4352 KB

Compile Error

warning: function is never used: `gcd`, #[warn(dead_code)] on by default
  --> ./Main.rs:82:1
   |
82 |   fn gcd(a: u64, b: u64) -> u64 {
   |  _^ starting here...
83 | |     if b == 0 { a } else { gcd(b, a % b) }
84 | | }
   | |_^ ...ending here

warning: function is never used: `lcm`, #[warn(dead_code)] on by default
  --> ./Main.rs:87:1
   |
87 |   fn lcm(a: u64, b: u64) -> u64 {
   |  _^ starting here...
88 | |     a / gcd(a, b) * b
89 | | }
   | |_^ ...ending here

warning: function is never used: `mod_fact`, #[warn(dead_code)] on by default
   --> ./Main.rs:130:1
    |
130 | fn mod_fact(n: u64, p: u64, fact: &Vec<u64>) -> (u64, u64) {
    | ^

warning: function is never used: `mod_comb`, #[warn(dead_code)] on by default
   --> ./Main.rs:145:1
    |
145 | fn mod_comb(n: u64, k: u64, p: u64, fact: &Vec<u64>) -> u64 {
    | ^

Judge Result

Set Name Sample All
Score / Max Score 0 / 0 600 / 600
Status
AC × 4
AC × 15
Set Name Test Cases
Sample sample_01.txt, sample_02.txt, sample_03.txt, sample_04.txt
All sample_01.txt, sample_02.txt, sample_03.txt, sample_04.txt, subtask_1_many_01.txt, subtask_1_many_02.txt, subtask_1_many_03.txt, subtask_1_many_04.txt, subtask_1_max_01.txt, subtask_1_max_02.txt, subtask_1_min_01.txt, subtask_1_randa_01.txt, subtask_1_randa_02.txt, subtask_1_randb_01.txt, subtask_1_randb_02.txt
Case Name Status Exec Time Memory
sample_01.txt AC 2 ms 4352 KB
sample_02.txt AC 2 ms 4352 KB
sample_03.txt AC 786 ms 4352 KB
sample_04.txt AC 2 ms 4352 KB
subtask_1_many_01.txt AC 624 ms 4352 KB
subtask_1_many_02.txt AC 391 ms 4352 KB
subtask_1_many_03.txt AC 595 ms 4352 KB
subtask_1_many_04.txt AC 515 ms 4352 KB
subtask_1_max_01.txt AC 3 ms 4352 KB
subtask_1_max_02.txt AC 2 ms 4352 KB
subtask_1_min_01.txt AC 2 ms 4352 KB
subtask_1_randa_01.txt AC 2 ms 4352 KB
subtask_1_randa_02.txt AC 2 ms 4352 KB
subtask_1_randb_01.txt AC 2 ms 4352 KB
subtask_1_randb_02.txt AC 2 ms 4352 KB