結果

問題 No.430 文字列検索
ユーザー tubo28tubo28
提出日時 2016-12-30 14:28:28
言語 Rust
(1.77.0)
結果
WA  
実行時間 -
コード長 2,522 bytes
コンパイル時間 12,694 ms
コンパイル使用メモリ 406,096 KB
実行使用メモリ 12,800 KB
最終ジャッジ日時 2024-05-09 12:42:18
合計ジャッジ時間 14,350 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,812 KB
testcase_01 WA -
testcase_02 AC 8 ms
6,940 KB
testcase_03 AC 9 ms
6,940 KB
testcase_04 AC 1 ms
6,940 KB
testcase_05 AC 1 ms
6,944 KB
testcase_06 AC 1 ms
6,944 KB
testcase_07 AC 1 ms
6,944 KB
testcase_08 AC 96 ms
12,800 KB
testcase_09 AC 1 ms
6,940 KB
testcase_10 WA -
testcase_11 AC 40 ms
6,940 KB
testcase_12 AC 40 ms
6,940 KB
testcase_13 AC 40 ms
6,944 KB
testcase_14 AC 34 ms
6,940 KB
testcase_15 AC 28 ms
6,944 KB
testcase_16 AC 12 ms
6,944 KB
testcase_17 AC 12 ms
6,944 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

use std::collections::BTreeMap;

pub static MOD:u64 = 1000000021;
pub static B:u64 = 10000;

fn main(){
    let mut sc = Scanner::new();
    while sc.ok() {
        let s:Vec<u64> = sc.next::<String>().chars()
            .map(|x| x as u64).collect();
        let mut mp = BTreeMap::new();
        let pow:Vec<_> = (0..20).map(|x| modpow(B, x)).collect();

        for l in 1..11 {
            let mut h = 0;
            for i in 0..s.len() {
                h = (h * B + s[i]) % MOD;
                if i >= l-1 {
                    *mp.entry(h).or_insert(0) += 1;
                    h = (h + MOD - s[i+1-l] * pow[l-1] % MOD) % MOD;
                }
            }
        }

        let m = sc.next();
        let mut ans:u64 = 0;
        for _ in 0..m {
            let h = sc.next::<String>().chars()
                .fold(0, |acc, x| (acc * B + x as u64) % MOD);
            let x = mp.get(&h).or(Some(&0)).unwrap().clone();
            ans += x;
        }
        println!("{}", ans);
    }
}

fn modpow(x: u64, y: u64) -> u64 {
    if y == 0 {
        1
    } else if y%2 == 1 {
        x * modpow(x, y-1) % MOD
    } else {
        let t = modpow(x, y/2);
        t * t % MOD
    }
}

#[allow(dead_code)]
struct Scanner { token_buffer: Vec<String>, index: usize }

#[allow(dead_code)]
impl Scanner {
    fn new() -> Scanner {
        Scanner { token_buffer: vec![], index: 0 }
    }

    fn next<T>(&mut self) -> T where T: std::str::FromStr {
        self.wrapped::<T>().unwrap()
    }

    fn wrapped<T>(&mut self) -> Option<T> where T: std::str::FromStr {
        self.get_token().and_then(|s| s.parse::<T>().ok())
    }

    fn ok(&mut self) -> bool {
        !self.eof()
    }

    fn eof(&mut self) -> bool {
        !self.read_line() || self.index >= self.token_buffer.len()
    }

    fn get_token(&mut self) -> Option<&String> {
        if !self.read_line() {
            None
        } else {
            self.index += 1;
            Some(&self.token_buffer[self.index - 1])
        }
    }

    fn read_line(&mut self) -> bool {
        while self.index >= self.token_buffer.len() {
            let mut st = String::new();
            while st.trim() == "" {
                match std::io::stdin().read_line(&mut st) {
                    Ok(l) if l > 0 => continue,
                    _ => return false
                }
            }
            self.token_buffer = st.split_whitespace()
                .map(|x| x.to_string()).collect();
            self.index = 0;
        }
        true
    }
}
0