結果
問題 | No.990 N×Mマス計算(Kの倍数) |
ユーザー | ziita |
提出日時 | 2020-02-14 23:40:28 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 215 ms / 2,000 ms |
コード長 | 5,704 bytes |
コンパイル時間 | 14,978 ms |
コンパイル使用メモリ | 386,140 KB |
実行使用メモリ | 10,096 KB |
最終ジャッジ日時 | 2024-04-27 20:25:48 |
合計ジャッジ時間 | 16,961 ms |
ジャッジサーバーID (参考情報) |
judge2 / judge5 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,812 KB |
testcase_01 | AC | 1 ms
6,940 KB |
testcase_02 | AC | 2 ms
6,940 KB |
testcase_03 | AC | 1 ms
6,940 KB |
testcase_04 | AC | 1 ms
6,940 KB |
testcase_05 | AC | 1 ms
6,940 KB |
testcase_06 | AC | 1 ms
6,944 KB |
testcase_07 | AC | 1 ms
6,944 KB |
testcase_08 | AC | 1 ms
6,940 KB |
testcase_09 | AC | 1 ms
6,940 KB |
testcase_10 | AC | 17 ms
6,940 KB |
testcase_11 | AC | 12 ms
6,944 KB |
testcase_12 | AC | 213 ms
6,944 KB |
testcase_13 | AC | 9 ms
6,940 KB |
testcase_14 | AC | 20 ms
6,940 KB |
testcase_15 | AC | 14 ms
6,944 KB |
testcase_16 | AC | 23 ms
6,940 KB |
testcase_17 | AC | 10 ms
6,940 KB |
testcase_18 | AC | 215 ms
6,944 KB |
testcase_19 | AC | 115 ms
6,944 KB |
testcase_20 | AC | 41 ms
10,096 KB |
ソースコード
#![allow(unused_imports)] #![allow(non_snake_case, unused)] use std::cmp::*; use std::collections::*; use std::ops::*; macro_rules! eprint { ($($t:tt)*) => {{ use ::std::io::Write; let _ = write!(::std::io::stderr(), $($t)*); }}; } macro_rules! eprintln { () => { eprintln!(""); }; ($($t:tt)*) => {{ use ::std::io::Write; let _ = writeln!(::std::io::stderr(), $($t)*); }}; } macro_rules! dbg { ($v:expr) => {{ let val = $v; eprintln!("[{}:{}] {} = {:?}", file!(), line!(), stringify!($v), val); val }} } macro_rules! mat { ($($e:expr),*) => { Vec::from(vec![$($e),*]) }; ($($e:expr,)*) => { Vec::from(vec![$($e),*]) }; ($e:expr; $d:expr) => { Vec::from(vec![$e; $d]) }; ($e:expr; $d:expr $(; $ds:expr)+) => { Vec::from(vec![mat![$e $(; $ds)*]; $d]) }; } macro_rules! ok { ($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => { $a$([$i])*.$f($($t),*) }; ($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { { let t = $e; ok!($a$([$i])*.$f($($es),*)$(@$t)*@t) } }; } pub fn readln() -> String { let mut line = String::new(); ::std::io::stdin().read_line(&mut line).unwrap_or_else(|e| panic!("{}", e)); line } macro_rules! read { ($($t:tt),*; $n:expr) => {{ let stdin = ::std::io::stdin(); let ret = ::std::io::BufRead::lines(stdin.lock()).take($n).map(|line| { let line = line.unwrap(); let mut it = line.split_whitespace(); _read!(it; $($t),*) }).collect::<Vec<_>>(); ret }}; ($($t:tt),*) => {{ let line = readln(); let mut it = line.split_whitespace(); _read!(it; $($t),*) }}; } macro_rules! _read { ($it:ident; [char]) => { _read!($it; String).chars().collect::<Vec<_>>() }; ($it:ident; [u8]) => { Vec::from(_read!($it; String).into_bytes()) }; ($it:ident; usize1) => { $it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1 }; ($it:ident; [usize1]) => { $it.map(|s| s.parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1).collect::<Vec<_>>() }; ($it:ident; [$t:ty]) => { $it.map(|s| s.parse::<$t>().unwrap_or_else(|e| panic!("{}", e))).collect::<Vec<_>>() }; ($it:ident; $t:ty) => { $it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<$t>().unwrap_or_else(|e| panic!("{}", e)) }; ($it:ident; $($t:tt),+) => { ($(_read!($it; $t)),*) }; } pub fn main() { let _ = ::std::thread::Builder::new().name("run".to_string()).stack_size(32 * 1024 * 1024).spawn(run).unwrap().join(); } const MOD: u32 = 1_000_000_007; const INF: usize = std::usize::MAX/2; pub trait SetMinMax { fn setmin(&mut self, v: Self) -> bool; fn setmax(&mut self, v: Self) -> bool; } impl<T> SetMinMax for T where T: PartialOrd { fn setmin(&mut self, v: T) -> bool { *self > v && { *self = v; true } } fn setmax(&mut self, v: T) -> bool { *self < v && { *self = v; true } } } // https://github.com/hatoo/competitive-rust-snippets/blob/master/src/binary_search.rs use std::cmp::Ordering; /// Equivalent to std::lowerbound and std::upperbound in c++ pub trait BinarySearch<T> { fn lower_bound(&self, x: &T) -> usize; fn upper_bound(&self, x: &T) -> usize; } impl<T: Ord> BinarySearch<T> for [T] { // 配列a内のv以上の最小のindex fn lower_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less => { low = mid + 1; } Ordering::Equal | Ordering::Greater => { high = mid; } } } low } // 配列a内のvより大きいの最小のindex fn upper_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less | Ordering::Equal => { low = mid + 1; } Ordering::Greater => { high = mid; } } } low } } fn gcd(a: i64, b: i64) -> i64{ if a < b {return gcd(b,a);} if b==0 {return a;} return gcd(b, a%b); } fn lcm(a: i64, b: i64) -> i64{ return a * (b /gcd(a, b)); } fn solve() { let (n,m,k) = read!(usize, usize,i64); let (op,mut b) = read!(String,[i64]); let a = read!(i64;n); if op=="+"{ let mut ah = HashMap::new(); let mut bh = HashMap::new(); for i in 0..n { let key = a[i] % k; let mut val: i64 = 1; if let Some(v) = ah.get(&key) { val += v; } ah.insert(key, val); } for i in 0..m { let key = b[i] % k; let mut val: i64 = 1; if let Some(v) = bh.get(&key) { val += v; } bh.insert(key, val); } let mut ans: i64 = 0; for (key,val) in ah.iter() { let target = (k - key)%k; if let Some(bval) = bh.get(&target) { ans += val * bval; } } println!("{}", ans); return; } else{ let mut div: Vec<i64> = vec![]; for i in 1..100000 { if i*i>k {break;} if k%i==0 { div.push(i); if i!=k/i {div.push(k/i);} } } let mut ah: Vec<i64> = vec![0;div.len()]; let mut bh: Vec<i64> = vec![0;div.len()]; for i in 0..n { let g = gcd(a[i], k); for j in 0..div.len(){ if div[j]==g { ah[j] += 1; } } } for i in 0..m { let g = gcd(b[i], k); for j in 0..div.len(){ if div[j]==g { bh[j] += 1; } } } let mut ans = 0; for i in 0..div.len() { for j in 0..div.len() { if (div[i]*div[j])%k==0 { ans += ah[i]*bh[j]; } } } println!("{}", ans); } } fn run() { solve(); }