├── rust-toolchain ├── Cargo.toml ├── .gitignore ├── atcoder ├── abc085_a.rs ├── abc085_b.rs ├── yahoo_procon2018_qual_a.rs ├── yahoo_procon2018_qual_b.rs ├── arc090_a.rs ├── agc039_d.rs ├── agc002_c.rs ├── abc085_c.rs ├── agc003_c.rs ├── abc134_a.rs ├── abc139_d.rs ├── tkppc4_1_a.rs ├── m_solutions2019_a.rs ├── arc089_a.rs ├── arc102_c.rs ├── abc142_a.rs ├── abc128_a.rs ├── abc143_a.rs ├── abc137_a.rs ├── cf17_final_b.rs ├── abc134_b.rs ├── m_solutions2019_b.rs ├── abc085_d.rs ├── abc130_a.rs ├── abc132_c.rs ├── abc133_a.rs ├── abc139_b.rs ├── abc138_a.rs ├── abc144_a.rs ├── abc132_a.rs ├── abc144_b.rs ├── abc139_a.rs ├── abc127_b.rs ├── abc143_c.rs ├── abc135_a.rs ├── abc136_a.rs ├── agc030_a.rs ├── abc138_c.rs ├── abc143_b.rs ├── abc136_b.rs ├── abc138_b.rs ├── abc142_b.rs ├── abc130_c.rs ├── abc137_b.rs ├── abc144_c.rs ├── abc127_a.rs ├── abc128_b.rs ├── abc130_b.rs ├── abc132_b.rs ├── abc135_b.rs ├── abc136_c.rs ├── agc029_a.rs ├── tkppc4_2_g.rs ├── arc082_b.rs ├── tkppc4_2_a.rs ├── abc139_c.rs ├── arc097_c.rs ├── abc126_a.rs ├── abc126_c.rs ├── abc126_b.rs ├── abc142_c.rs ├── abc127_c.rs ├── tkppc4_1_b.rs ├── cf17_final_a.rs ├── tkppc4_1_c.rs ├── abc135_c.rs ├── arc094_c.rs ├── jsc2019_qual_a.rs ├── past201912_c.rs ├── tkppc4_2_h.rs ├── abc149_a.rs ├── abc133_c.rs ├── abc137_c.rs ├── abc134_e.rs ├── mujin_pc_2017_a.rs ├── abc133_d.rs ├── tenka1_2017_c.rs ├── past201912_a.rs ├── abc150_a.rs ├── agc014_d.rs ├── agc038_a.rs ├── agc024_c.rs ├── abc133_b.rs ├── keyence2020_a.rs ├── abc150_b.rs ├── abc142_d.rs ├── abc143_d.rs ├── abc144_d.rs ├── abc127_d.rs ├── abc110_a.rs ├── agc020_a.rs ├── abc149_b.rs ├── code_festival_2018_quala_a.rs ├── abc134_c.rs ├── agc031_b.rs ├── code_festival_2017_quala_d.rs ├── abc123_d.rs ├── tkppc4_1_f.rs ├── abc137_d.rs ├── past201912_b.rs ├── arc086_b.rs ├── jsc2019_final_a.rs ├── abc139_f.rs ├── abc141_f.rs ├── abc126_f.rs ├── agc001_c.rs ├── jsc2019_qual_b.rs ├── mujin_pc_2017_b.rs ├── abc135_d.rs ├── abc128_f.rs ├── agc029_b.rs ├── code_festival_2017_qualc_d.rs ├── abc130_d.rs ├── tkppc4_1_d.rs ├── abc144_e.rs ├── agc027_b.rs ├── arc066_b.rs ├── cf16_exhibition_final_g.rs ├── keyence2020_b.rs ├── past201912_d.rs ├── agc032_b.rs ├── agc027_a.rs ├── ddcc2020_qual_a.rs ├── abc130_e.rs ├── abc142_e.rs ├── abc149_c.rs ├── jsc2019_qual_d.rs ├── agc018_b.rs ├── abc134_d.rs ├── keyence2020_c.rs ├── abc143_f.rs ├── agc005_c.rs ├── arc069_c.rs ├── arc092_d.rs ├── abc128_c.rs ├── arc091_c.rs ├── arc079_b.rs ├── agc035_a.rs ├── arc088_b.rs └── past201912_f.rs ├── pack_bin.sh ├── codejam └── 2019-round1b │ └── draupnir.rs └── aoj └── 2900.rs /rust-toolchain: -------------------------------------------------------------------------------- 1 | 1.42.0 -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "rust-programming-contest-solutions" 3 | version = "0.1.0" 4 | authors = ["kenkoooo "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | rand = "0.7" 9 | num-bigint = "0.3.0" 10 | 11 | #[profile.release] 12 | #debug= true -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | **/target/ 2 | **/*.rs.bk 3 | **/.idea/ 4 | **/*.lock 5 | **/*.iml 6 | /rls/ 7 | **/.vscode/ 8 | 9 | 10 | #Added by cargo 11 | # 12 | #already existing elements are commented out 13 | 14 | /target 15 | #**/*.rs.bk 16 | 17 | 18 | #Added by cargo 19 | # 20 | #already existing elements are commented out 21 | 22 | #/target 23 | #**/*.rs.bk 24 | -------------------------------------------------------------------------------- /atcoder/abc085_a.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | fn main() { 4 | let s = read_line(); 5 | print!("2018"); 6 | println!("{}", &s[4..s.len()]); 7 | } 8 | 9 | fn read_line() -> String { 10 | let stdin = io::stdin(); 11 | let mut buf = String::new(); 12 | stdin.read_line(&mut buf).unwrap(); 13 | buf 14 | } 15 | 16 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 17 | read_line() 18 | .split(' ') 19 | .map(|a| a.trim().parse().unwrap()) 20 | .collect() 21 | } -------------------------------------------------------------------------------- /pack_bin.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh -x 2 | 3 | BIN_FILE_NAME=./target/release/${1} 4 | SH_FILE_NAME=./target/release/${1}.sh 5 | 6 | cargo rustc --bin ${1} --release -- -C opt-level=s -C lto -C link-args=-Wl,-x,-S -C panic=abort 7 | strip ${BIN_FILE_NAME} 8 | upx ${BIN_FILE_NAME} 9 | cat src/bin/${1}.rs | sed -e 's/^/# /g' > ${SH_FILE_NAME} 10 | echo "cat << '_EOF' | base64 -d > /tmp/exec" >> ${SH_FILE_NAME} 11 | base64 ${BIN_FILE_NAME} >> ${SH_FILE_NAME} 12 | echo "_EOF" >> ${SH_FILE_NAME} 13 | echo "chmod +x /tmp/exec" >> ${SH_FILE_NAME} 14 | echo "/tmp/exec" >> ${SH_FILE_NAME} 15 | chmod +x ${SH_FILE_NAME} 16 | -------------------------------------------------------------------------------- /atcoder/abc085_b.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::collections::BTreeSet; 3 | 4 | fn main() { 5 | let n = read_values::()[0]; 6 | let d = (0..n).map(|_| read_values::()[0]).collect::>(); 7 | println!("{}", d.len()); 8 | } 9 | 10 | fn read_line() -> String { 11 | let stdin = io::stdin(); 12 | let mut buf = String::new(); 13 | stdin.read_line(&mut buf).unwrap(); 14 | buf 15 | } 16 | 17 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 18 | read_line() 19 | .split(' ') 20 | .map(|a| a.trim().parse().unwrap()) 21 | .collect() 22 | } -------------------------------------------------------------------------------- /atcoder/yahoo_procon2018_qual_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = read_line().trim().bytes().collect::>(); 3 | let yah = "yah".to_owned().trim().bytes().collect::>(); 4 | 5 | if s[0] == yah[0] && s[1] == yah[1] && s[2] == yah[2] && s[3] == s[4] { 6 | println!("YES"); 7 | } else { 8 | println!("NO"); 9 | } 10 | } 11 | 12 | fn read_line() -> String { 13 | let stdin = std::io::stdin(); 14 | let mut buf = String::new(); 15 | stdin.read_line(&mut buf).unwrap(); 16 | buf 17 | } 18 | 19 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug, { 20 | read_line() 21 | .split(' ') 22 | .map(|a| a.trim().parse().unwrap()) 23 | .collect() 24 | } -------------------------------------------------------------------------------- /atcoder/yahoo_procon2018_qual_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (x, k) = { 3 | let v = read_values::(); 4 | (v[0], v[1]) 5 | }; 6 | let mut y = 1; 7 | for _ in 0..k { 8 | y *= 10; 9 | } 10 | if x / y > 0 { 11 | println!("{}", x / y * y + y); 12 | } else { 13 | println!("{}", y); 14 | } 15 | } 16 | 17 | fn read_line() -> String { 18 | let stdin = std::io::stdin(); 19 | let mut buf = String::new(); 20 | stdin.read_line(&mut buf).unwrap(); 21 | buf 22 | } 23 | 24 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug, { 25 | read_line() 26 | .split(' ') 27 | .map(|a| a.trim().parse().unwrap()) 28 | .collect() 29 | } -------------------------------------------------------------------------------- /atcoder/arc090_a.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let n = read_values::()[0]; 5 | let a = (0..2).map(|_| read_values::()).collect::>(); 6 | let mut dp = vec![vec![0; n]; 2]; 7 | dp[0][0] = a[0][0]; 8 | for i in 1..n { 9 | dp[0][i] = dp[0][i - 1] + a[0][i]; 10 | } 11 | dp[1][0] = dp[0][0] + a[1][0]; 12 | for i in 1..n { 13 | dp[1][i] = cmp::max(dp[1][i - 1], dp[0][i]) + a[1][i]; 14 | } 15 | 16 | println!("{}", dp[1][n - 1]); 17 | } 18 | 19 | fn read_line() -> String { 20 | let stdin = std::io::stdin(); 21 | let mut buf = String::new(); 22 | stdin.read_line(&mut buf).unwrap(); 23 | buf 24 | } 25 | 26 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 27 | read_line() 28 | .split(' ') 29 | .map(|a| a.trim().parse().unwrap()) 30 | .collect() 31 | } 32 | -------------------------------------------------------------------------------- /atcoder/agc039_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | } 5 | 6 | pub struct Scanner { 7 | stdin: R, 8 | } 9 | 10 | impl Scanner { 11 | pub fn read(&mut self) -> T { 12 | use std::io::Read; 13 | let buf = self 14 | .stdin 15 | .by_ref() 16 | .bytes() 17 | .map(|b| b.unwrap()) 18 | .skip_while(|&b| b == b' ' || b == b'\n') 19 | .take_while(|&b| b != b' ' && b != b'\n') 20 | .collect::>(); 21 | unsafe { std::str::from_utf8_unchecked(&buf) } 22 | .parse() 23 | .ok() 24 | .expect("Parse error.") 25 | } 26 | pub fn vec(&mut self, n: usize) -> Vec { 27 | (0..n).map(|_| self.read()).collect() 28 | } 29 | pub fn chars(&mut self) -> Vec { 30 | self.read::().chars().collect() 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /atcoder/agc002_c.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | fn main() { 4 | let (n, l) = { 5 | let v = read_values::(); 6 | (v[0], v[1]) 7 | }; 8 | 9 | let a = read_values::(); 10 | let mut x = n; 11 | for i in 0..(n - 1) { 12 | if a[i] + a[i + 1] >= l { 13 | x = i; 14 | break; 15 | } 16 | } 17 | 18 | if x == n { 19 | println!("Impossible"); 20 | return; 21 | } 22 | 23 | println!("Possible"); 24 | for i in 0..x { 25 | println!("{}", i + 1); 26 | } 27 | for i in (x..(n - 1)).rev() { 28 | println!("{}", i + 1); 29 | } 30 | } 31 | 32 | fn read_line() -> String { 33 | let stdin = io::stdin(); 34 | let mut buf = String::new(); 35 | stdin.read_line(&mut buf).unwrap(); 36 | buf 37 | } 38 | 39 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 40 | read_line() 41 | .split(' ') 42 | .map(|a| a.trim().parse().unwrap()) 43 | .collect() 44 | } -------------------------------------------------------------------------------- /atcoder/abc085_c.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | fn main() { 4 | let (n, y) = { 5 | let v = read_values::(); 6 | (v[0], v[1]) 7 | }; 8 | for i in 0..2001 { 9 | if i > n || 10000 * i > y { 10 | continue; 11 | } 12 | for j in 0..4001 { 13 | if n < i + j { 14 | continue; 15 | } 16 | let sum = 10000 * i + 5000 * j + (n - i - j) * 1000; 17 | if sum == y { 18 | println!("{} {} {}", i, j, n - i - j); 19 | return; 20 | } 21 | } 22 | } 23 | println!("-1 -1 -1"); 24 | } 25 | 26 | fn read_line() -> String { 27 | let stdin = io::stdin(); 28 | let mut buf = String::new(); 29 | stdin.read_line(&mut buf).unwrap(); 30 | buf 31 | } 32 | 33 | fn read_values() -> Vec 34 | where 35 | T: std::str::FromStr, 36 | T::Err: std::fmt::Debug, 37 | { 38 | read_line() 39 | .split(' ') 40 | .map(|a| a.trim().parse().unwrap()) 41 | .collect() 42 | } 43 | -------------------------------------------------------------------------------- /atcoder/agc003_c.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::collections::BTreeMap; 3 | 4 | fn main() { 5 | let n = read_values::()[0]; 6 | let mut array = (0..n).map(|_| read_values::()[0]).collect::>(); 7 | let mut map = BTreeMap::new(); 8 | for i in 0..n { 9 | if i % 2 == 0 { 10 | map.insert(array[i], true); 11 | } else { 12 | map.insert(array[i], false); 13 | } 14 | } 15 | 16 | array.sort(); 17 | let mut count = 0; 18 | for i in 0..n { 19 | if i % 2 != 0 && *map.get(&array[i]).unwrap() { 20 | count += 1; 21 | } 22 | } 23 | println!("{}", count); 24 | } 25 | 26 | fn read_line() -> String { 27 | let stdin = io::stdin(); 28 | let mut buf = String::new(); 29 | stdin.read_line(&mut buf).unwrap(); 30 | buf 31 | } 32 | 33 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 34 | read_line() 35 | .split(' ') 36 | .map(|a| a.trim().parse().unwrap()) 37 | .collect() 38 | } -------------------------------------------------------------------------------- /atcoder/abc134_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let r: u64 = sc.read(); 5 | println!("{}", 3 * r * r); 6 | } 7 | 8 | pub struct Scanner { 9 | stdin: R, 10 | } 11 | 12 | impl Scanner { 13 | pub fn read(&mut self) -> T { 14 | use std::io::Read; 15 | let buf = self 16 | .stdin 17 | .by_ref() 18 | .bytes() 19 | .map(|b| b.unwrap()) 20 | .skip_while(|&b| b == b' ' || b == b'\n') 21 | .take_while(|&b| b != b' ' && b != b'\n') 22 | .collect::>(); 23 | unsafe { std::str::from_utf8_unchecked(&buf) } 24 | .parse() 25 | .ok() 26 | .expect("Parse error.") 27 | } 28 | pub fn vec(&mut self, n: usize) -> Vec { 29 | (0..n).map(|_| self.read()).collect() 30 | } 31 | pub fn chars(&mut self) -> Vec { 32 | self.read::().chars().collect() 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /atcoder/abc139_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: u64 = sc.read(); 5 | let ans = n * (n - 1) / 2; 6 | println!("{}", ans); 7 | } 8 | 9 | pub struct Scanner { 10 | stdin: R, 11 | } 12 | 13 | impl Scanner { 14 | pub fn read(&mut self) -> T { 15 | use std::io::Read; 16 | let buf = self 17 | .stdin 18 | .by_ref() 19 | .bytes() 20 | .map(|b| b.unwrap()) 21 | .skip_while(|&b| b == b' ' || b == b'\n') 22 | .take_while(|&b| b != b' ' && b != b'\n') 23 | .collect::>(); 24 | unsafe { std::str::from_utf8_unchecked(&buf) } 25 | .parse() 26 | .ok() 27 | .expect("Parse error.") 28 | } 29 | pub fn vec(&mut self, n: usize) -> Vec { 30 | (0..n).map(|_| self.read()).collect() 31 | } 32 | pub fn chars(&mut self) -> Vec { 33 | self.read::().chars().collect() 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /atcoder/tkppc4_1_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let _: usize = sc.read(); 6 | println!("{}", n - 1); 7 | } 8 | 9 | pub struct Scanner { 10 | stdin: R, 11 | } 12 | 13 | impl Scanner { 14 | pub fn read(&mut self) -> T { 15 | use std::io::Read; 16 | let buf = self 17 | .stdin 18 | .by_ref() 19 | .bytes() 20 | .map(|b| b.unwrap()) 21 | .skip_while(|&b| b == b' ' || b == b'\n') 22 | .take_while(|&b| b != b' ' && b != b'\n') 23 | .collect::>(); 24 | unsafe { std::str::from_utf8_unchecked(&buf) } 25 | .parse() 26 | .ok() 27 | .expect("Parse error.") 28 | } 29 | pub fn vec(&mut self, n: usize) -> Vec { 30 | (0..n).map(|_| self.read()).collect() 31 | } 32 | pub fn chars(&mut self) -> Vec { 33 | self.read::().chars().collect() 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /atcoder/m_solutions2019_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | println!("{}", 180 * n - 360); 6 | } 7 | 8 | pub struct Scanner { 9 | stdin: R, 10 | } 11 | 12 | impl Scanner { 13 | pub fn read(&mut self) -> T { 14 | use std::io::Read; 15 | let buf = self 16 | .stdin 17 | .by_ref() 18 | .bytes() 19 | .map(|b| b.unwrap()) 20 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 21 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 22 | .collect::>(); 23 | unsafe { std::str::from_utf8_unchecked(&buf) } 24 | .parse() 25 | .ok() 26 | .expect("Parse error.") 27 | } 28 | pub fn vec(&mut self, n: usize) -> Vec { 29 | (0..n).map(|_| self.read()).collect() 30 | } 31 | pub fn chars(&mut self) -> Vec { 32 | self.read::().chars().collect() 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /atcoder/arc089_a.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | fn main() { 4 | let n = read_values::()[0]; 5 | let mut cur = (0, 0); 6 | let mut time = 0; 7 | for _ in 0..n { 8 | let (t, x, y) = { 9 | let v = read_values::(); 10 | (v[0], v[1], v[2]) 11 | }; 12 | 13 | let duration = t - time; 14 | let (cx, cy) = cur; 15 | let length = (cx - x).abs() + (cy - y).abs(); 16 | if length > duration { 17 | println!("No"); 18 | return; 19 | } 20 | if (duration - length) % 2 != 0 { 21 | println!("No"); 22 | return; 23 | } 24 | time = t; 25 | cur = (x, y) 26 | } 27 | println!("Yes"); 28 | } 29 | 30 | fn read_line() -> String { 31 | let stdin = io::stdin(); 32 | let mut buf = String::new(); 33 | stdin.read_line(&mut buf).unwrap(); 34 | buf 35 | } 36 | 37 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 38 | read_line() 39 | .split(' ') 40 | .map(|a| a.trim().parse().unwrap()) 41 | .collect() 42 | } -------------------------------------------------------------------------------- /atcoder/arc102_c.rs: -------------------------------------------------------------------------------- 1 | const MOD: usize = 998244353; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let k: usize = sc.read(); 8 | let n: usize = sc.read(); 9 | } 10 | 11 | pub struct Scanner { 12 | stdin: R, 13 | } 14 | 15 | impl Scanner { 16 | pub fn read(&mut self) -> T { 17 | use std::io::Read; 18 | let buf = self 19 | .stdin 20 | .by_ref() 21 | .bytes() 22 | .map(|b| b.unwrap()) 23 | .skip_while(|&b| b == b' ' || b == b'\n') 24 | .take_while(|&b| b != b' ' && b != b'\n') 25 | .collect::>(); 26 | unsafe { std::str::from_utf8_unchecked(&buf) } 27 | .parse() 28 | .ok() 29 | .expect("Parse error.") 30 | } 31 | pub fn vec(&mut self, n: usize) -> Vec { 32 | (0..n).map(|_| self.read()).collect() 33 | } 34 | pub fn chars(&mut self) -> Vec { 35 | self.read::().chars().collect() 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /atcoder/abc142_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let odds = (n + 1) / 2; 6 | println!("{}", (odds as f64) / (n as f64)); 7 | } 8 | 9 | pub struct Scanner { 10 | stdin: R, 11 | } 12 | 13 | impl Scanner { 14 | pub fn read(&mut self) -> T { 15 | use std::io::Read; 16 | let buf = self 17 | .stdin 18 | .by_ref() 19 | .bytes() 20 | .map(|b| b.unwrap()) 21 | .skip_while(|&b| b == b' ' || b == b'\n') 22 | .take_while(|&b| b != b' ' && b != b'\n') 23 | .collect::>(); 24 | unsafe { std::str::from_utf8_unchecked(&buf) } 25 | .parse() 26 | .ok() 27 | .expect("Parse error.") 28 | } 29 | pub fn vec(&mut self, n: usize) -> Vec { 30 | (0..n).map(|_| self.read()).collect() 31 | } 32 | pub fn chars(&mut self) -> Vec { 33 | self.read::().chars().collect() 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /atcoder/abc128_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: usize = sc.read(); 5 | let b: usize = sc.read(); 6 | println!("{}", (a * 3 + b) / 2); 7 | } 8 | 9 | pub struct Scanner { 10 | stdin: R, 11 | } 12 | 13 | impl Scanner { 14 | pub fn read(&mut self) -> T { 15 | use std::io::Read; 16 | let buf = self 17 | .stdin 18 | .by_ref() 19 | .bytes() 20 | .map(|b| b.unwrap()) 21 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 22 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 23 | .collect::>(); 24 | unsafe { std::str::from_utf8_unchecked(&buf) } 25 | .parse() 26 | .ok() 27 | .expect("Parse error.") 28 | } 29 | pub fn vec(&mut self, n: usize) -> Vec { 30 | (0..n).map(|_| self.read()).collect() 31 | } 32 | pub fn chars(&mut self) -> Vec { 33 | self.read::().chars().collect() 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /atcoder/abc143_a.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let a: i64 = sc.read(); 7 | let b: i64 = sc.read(); 8 | println!("{}", cmp::max(a - 2 * b, 0)); 9 | } 10 | 11 | pub struct Scanner { 12 | stdin: R, 13 | } 14 | 15 | impl Scanner { 16 | pub fn read(&mut self) -> T { 17 | use std::io::Read; 18 | let buf = self 19 | .stdin 20 | .by_ref() 21 | .bytes() 22 | .map(|b| b.unwrap()) 23 | .skip_while(|&b| b == b' ' || b == b'\n') 24 | .take_while(|&b| b != b' ' && b != b'\n') 25 | .collect::>(); 26 | unsafe { std::str::from_utf8_unchecked(&buf) } 27 | .parse() 28 | .ok() 29 | .expect("Parse error.") 30 | } 31 | pub fn vec(&mut self, n: usize) -> Vec { 32 | (0..n).map(|_| self.read()).collect() 33 | } 34 | pub fn chars(&mut self) -> Vec { 35 | self.read::().chars().collect() 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /atcoder/abc137_a.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let a: i64 = sc.read(); 7 | let b: i64 = sc.read(); 8 | println!("{}", cmp::max(cmp::max(a + b, a - b), a * b)); 9 | } 10 | 11 | pub struct Scanner { 12 | stdin: R, 13 | } 14 | 15 | impl Scanner { 16 | pub fn read(&mut self) -> T { 17 | use std::io::Read; 18 | let buf = self 19 | .stdin 20 | .by_ref() 21 | .bytes() 22 | .map(|b| b.unwrap()) 23 | .skip_while(|&b| b == b' ' || b == b'\n') 24 | .take_while(|&b| b != b' ' && b != b'\n') 25 | .collect::>(); 26 | unsafe { std::str::from_utf8_unchecked(&buf) } 27 | .parse() 28 | .ok() 29 | .expect("Parse error.") 30 | } 31 | pub fn vec(&mut self, n: usize) -> Vec { 32 | (0..n).map(|_| self.read()).collect() 33 | } 34 | pub fn chars(&mut self) -> Vec { 35 | self.read::().chars().collect() 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /atcoder/cf17_final_b.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::cmp; 3 | 4 | fn main() { 5 | let s = read_line().trim().to_owned(); 6 | let (mut a, mut b, mut c) = (0, 0, 0); 7 | 8 | for ch in s.chars(){ 9 | if ch == 'a' { 10 | a += 1; 11 | } else if ch == 'b' { 12 | b += 1; 13 | } else { 14 | c += 1; 15 | } 16 | } 17 | let max = cmp::max(a, cmp::max(b, c)); 18 | let min = cmp::min(a, cmp::min(b, c)); 19 | if max - min <= 1 { 20 | println!("YES"); 21 | } else { 22 | println!("NO"); 23 | } 24 | } 25 | 26 | fn read_line() -> String { 27 | let stdin = io::stdin(); 28 | let mut buf = String::new(); 29 | stdin.read_line(&mut buf).unwrap(); 30 | buf 31 | } 32 | 33 | fn read() -> T 34 | where T: std::str::FromStr, 35 | T::Err: std::fmt::Debug 36 | { 37 | read_line().trim().parse().unwrap() 38 | } 39 | 40 | fn read_values() -> Vec 41 | where T: std::str::FromStr, 42 | T::Err: std::fmt::Debug 43 | { 44 | read_line() 45 | .split(' ') 46 | .map(|a| a.trim().parse().unwrap()) 47 | .collect() 48 | } -------------------------------------------------------------------------------- /atcoder/abc134_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let d: usize = sc.read(); 6 | let d = d * 2 + 1; 7 | let ans = (n + d - 1) / d; 8 | println!("{}", ans); 9 | } 10 | 11 | pub struct Scanner { 12 | stdin: R, 13 | } 14 | 15 | impl Scanner { 16 | pub fn read(&mut self) -> T { 17 | use std::io::Read; 18 | let buf = self 19 | .stdin 20 | .by_ref() 21 | .bytes() 22 | .map(|b| b.unwrap()) 23 | .skip_while(|&b| b == b' ' || b == b'\n') 24 | .take_while(|&b| b != b' ' && b != b'\n') 25 | .collect::>(); 26 | unsafe { std::str::from_utf8_unchecked(&buf) } 27 | .parse() 28 | .ok() 29 | .expect("Parse error.") 30 | } 31 | pub fn vec(&mut self, n: usize) -> Vec { 32 | (0..n).map(|_| self.read()).collect() 33 | } 34 | pub fn chars(&mut self) -> Vec { 35 | self.read::().chars().collect() 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /atcoder/m_solutions2019_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let s = sc.chars().into_iter().filter(|&c| c == 'x').count() < 8; 5 | println!("{}", if s { "YES" } else { "NO" }); 6 | } 7 | 8 | pub struct Scanner { 9 | stdin: R, 10 | } 11 | 12 | impl Scanner { 13 | pub fn read(&mut self) -> T { 14 | use std::io::Read; 15 | let buf = self 16 | .stdin 17 | .by_ref() 18 | .bytes() 19 | .map(|b| b.unwrap()) 20 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 21 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 22 | .collect::>(); 23 | unsafe { std::str::from_utf8_unchecked(&buf) } 24 | .parse() 25 | .ok() 26 | .expect("Parse error.") 27 | } 28 | pub fn vec(&mut self, n: usize) -> Vec { 29 | (0..n).map(|_| self.read()).collect() 30 | } 31 | pub fn chars(&mut self) -> Vec { 32 | self.read::().chars().collect() 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /atcoder/abc085_d.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::collections::BTreeSet; 3 | 4 | fn main() { 5 | let (n, mut h) = { 6 | let v = read_values::(); 7 | (v[0], v[1] as i64) 8 | }; 9 | let mut vec = Vec::new(); 10 | for _ in 0..n { 11 | let v = read_values::(); 12 | vec.push((v[0], true)); 13 | vec.push((v[1], false)); 14 | } 15 | vec.sort(); 16 | 17 | let mut ans = 0; 18 | for i in (0..vec.len()).rev() { 19 | let (atk, inf) = vec[i]; 20 | if inf { 21 | ans += (h + atk - 1) / atk; 22 | break; 23 | } else { 24 | ans += 1; 25 | h -= atk; 26 | } 27 | if h <= 0 { 28 | break; 29 | } 30 | } 31 | println!("{}", ans); 32 | } 33 | 34 | fn read_line() -> String { 35 | let stdin = io::stdin(); 36 | let mut buf = String::new(); 37 | stdin.read_line(&mut buf).unwrap(); 38 | buf 39 | } 40 | 41 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 42 | read_line() 43 | .split(' ') 44 | .map(|a| a.trim().parse().unwrap()) 45 | .collect() 46 | } -------------------------------------------------------------------------------- /atcoder/abc130_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let x: u32 = sc.read(); 5 | let a: u32 = sc.read(); 6 | if x < a { 7 | println!("0"); 8 | } else { 9 | println!("10"); 10 | } 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n') 26 | .take_while(|&b| b != b' ' && b != b'\n') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc132_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut d: Vec = sc.vec(n); 6 | d.sort(); 7 | 8 | let x = n / 2; 9 | 10 | println!("{}", d[x] - d[x - 1]); 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n') 26 | .take_while(|&b| b != b' ' && b != b'\n') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc133_a.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let a: usize = sc.read(); 8 | let b: usize = sc.read(); 9 | println!("{}", cmp::min(b, n * a)); 10 | } 11 | 12 | pub struct Scanner { 13 | stdin: R, 14 | } 15 | 16 | impl Scanner { 17 | pub fn read(&mut self) -> T { 18 | use std::io::Read; 19 | let buf = self 20 | .stdin 21 | .by_ref() 22 | .bytes() 23 | .map(|b| b.unwrap()) 24 | .skip_while(|&b| b == b' ' || b == b'\n') 25 | .take_while(|&b| b != b' ' && b != b'\n') 26 | .collect::>(); 27 | unsafe { std::str::from_utf8_unchecked(&buf) } 28 | .parse() 29 | .ok() 30 | .expect("Parse error.") 31 | } 32 | pub fn vec(&mut self, n: usize) -> Vec { 33 | (0..n).map(|_| self.read()).collect() 34 | } 35 | pub fn chars(&mut self) -> Vec { 36 | self.read::().chars().collect() 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /atcoder/abc139_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: usize = sc.read(); 5 | let b: usize = sc.read(); 6 | let c = a - 1; 7 | let d = b - 1; 8 | let ans = (d + c - 1) / c; 9 | println!("{}", ans); 10 | } 11 | 12 | pub struct Scanner { 13 | stdin: R, 14 | } 15 | 16 | impl Scanner { 17 | pub fn read(&mut self) -> T { 18 | use std::io::Read; 19 | let buf = self 20 | .stdin 21 | .by_ref() 22 | .bytes() 23 | .map(|b| b.unwrap()) 24 | .skip_while(|&b| b == b' ' || b == b'\n') 25 | .take_while(|&b| b != b' ' && b != b'\n') 26 | .collect::>(); 27 | unsafe { std::str::from_utf8_unchecked(&buf) } 28 | .parse() 29 | .ok() 30 | .expect("Parse error.") 31 | } 32 | pub fn vec(&mut self, n: usize) -> Vec { 33 | (0..n).map(|_| self.read()).collect() 34 | } 35 | pub fn chars(&mut self) -> Vec { 36 | self.read::().chars().collect() 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /atcoder/abc138_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: usize = sc.read(); 5 | let s = sc.read::(); 6 | if a < 3200 { 7 | println!("red"); 8 | } else { 9 | println!("{}", s); 10 | } 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n') 26 | .take_while(|&b| b != b' ' && b != b'\n') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc144_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: usize = sc.read(); 5 | let b: usize = sc.read(); 6 | if a < 10 && b < 10 { 7 | println!("{}", a * b); 8 | } else { 9 | println!("-1"); 10 | } 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n') 26 | .take_while(|&b| b != b' ' && b != b'\n') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc132_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let mut s = sc.chars(); 5 | s.sort(); 6 | if s[0] == s[1] && s[2] == s[3] && s[1] != s[2] { 7 | println!("Yes"); 8 | } else { 9 | println!("No"); 10 | } 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n') 26 | .take_while(|&b| b != b' ' && b != b'\n') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc144_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | for i in 1..10 { 6 | if n % i == 0 && n / i < 10 { 7 | println!("Yes"); 8 | return; 9 | } 10 | } 11 | println!("No"); 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc139_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let s = sc.chars(); 5 | let t = sc.chars(); 6 | let mut ans = 0; 7 | for i in 0..3 { 8 | if s[i] == t[i] { 9 | ans += 1; 10 | } 11 | } 12 | println!("{}", ans); 13 | } 14 | 15 | pub struct Scanner { 16 | stdin: R, 17 | } 18 | 19 | impl Scanner { 20 | pub fn read(&mut self) -> T { 21 | use std::io::Read; 22 | let buf = self 23 | .stdin 24 | .by_ref() 25 | .bytes() 26 | .map(|b| b.unwrap()) 27 | .skip_while(|&b| b == b' ' || b == b'\n') 28 | .take_while(|&b| b != b' ' && b != b'\n') 29 | .collect::>(); 30 | unsafe { std::str::from_utf8_unchecked(&buf) } 31 | .parse() 32 | .ok() 33 | .expect("Parse error.") 34 | } 35 | pub fn vec(&mut self, n: usize) -> Vec { 36 | (0..n).map(|_| self.read()).collect() 37 | } 38 | pub fn chars(&mut self) -> Vec { 39 | self.read::().chars().collect() 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /atcoder/abc127_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let r: usize = sc.read(); 5 | let d: usize = sc.read(); 6 | let mut x: usize = sc.read(); 7 | for _ in 0..10 { 8 | x = r * x - d; 9 | println!("{}", x); 10 | } 11 | } 12 | 13 | pub struct Scanner { 14 | stdin: R, 15 | } 16 | 17 | impl Scanner { 18 | pub fn read(&mut self) -> T { 19 | use std::io::Read; 20 | let buf = self 21 | .stdin 22 | .by_ref() 23 | .bytes() 24 | .map(|b| b.unwrap()) 25 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 26 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 27 | .collect::>(); 28 | unsafe { std::str::from_utf8_unchecked(&buf) } 29 | .parse() 30 | .ok() 31 | .expect("Parse error.") 32 | } 33 | pub fn vec(&mut self, n: usize) -> Vec { 34 | (0..n).map(|_| self.read()).collect() 35 | } 36 | pub fn chars(&mut self) -> Vec { 37 | self.read::().chars().collect() 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /atcoder/abc143_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let s = sc.chars(); 6 | let mut ans = 1; 7 | for i in 1..n { 8 | if s[i - 1] != s[i] { 9 | ans += 1; 10 | } 11 | } 12 | println!("{}", ans); 13 | } 14 | 15 | pub struct Scanner { 16 | stdin: R, 17 | } 18 | 19 | impl Scanner { 20 | pub fn read(&mut self) -> T { 21 | use std::io::Read; 22 | let buf = self 23 | .stdin 24 | .by_ref() 25 | .bytes() 26 | .map(|b| b.unwrap()) 27 | .skip_while(|&b| b == b' ' || b == b'\n') 28 | .take_while(|&b| b != b' ' && b != b'\n') 29 | .collect::>(); 30 | unsafe { std::str::from_utf8_unchecked(&buf) } 31 | .parse() 32 | .ok() 33 | .expect("Parse error.") 34 | } 35 | pub fn vec(&mut self, n: usize) -> Vec { 36 | (0..n).map(|_| self.read()).collect() 37 | } 38 | pub fn chars(&mut self) -> Vec { 39 | self.read::().chars().collect() 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /atcoder/abc135_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: i64 = sc.read(); 5 | let b: i64 = sc.read(); 6 | let x = (a + b) / 2; 7 | if (a - x).abs() == (b - x).abs() { 8 | println!("{}", x); 9 | } else { 10 | println!("IMPOSSIBLE"); 11 | } 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc136_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: u64 = sc.read(); 5 | let b: u64 = sc.read(); 6 | let c: u64 = sc.read(); 7 | let rest = a - b; 8 | if c > rest { 9 | println!("{}", c - rest); 10 | } else { 11 | println!("0"); 12 | } 13 | } 14 | 15 | pub struct Scanner { 16 | stdin: R, 17 | } 18 | 19 | impl Scanner { 20 | pub fn read(&mut self) -> T { 21 | use std::io::Read; 22 | let buf = self 23 | .stdin 24 | .by_ref() 25 | .bytes() 26 | .map(|b| b.unwrap()) 27 | .skip_while(|&b| b == b' ' || b == b'\n') 28 | .take_while(|&b| b != b' ' && b != b'\n') 29 | .collect::>(); 30 | unsafe { std::str::from_utf8_unchecked(&buf) } 31 | .parse() 32 | .ok() 33 | .expect("Parse error.") 34 | } 35 | pub fn vec(&mut self, n: usize) -> Vec { 36 | (0..n).map(|_| self.read()).collect() 37 | } 38 | pub fn chars(&mut self) -> Vec { 39 | self.read::().chars().collect() 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /atcoder/agc030_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { reader: s.lock() }; 4 | let a: usize = sc.read(); 5 | let b: usize = sc.read(); 6 | let c: usize = sc.read(); 7 | if c > a + b { 8 | println!("{}", a + b + 1 + b); 9 | } else { 10 | println!("{}", c + b); 11 | } 12 | } 13 | 14 | pub struct Scanner { 15 | reader: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .reader 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn read_vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc138_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n = sc.read(); 5 | let mut v: Vec = sc.vec(n); 6 | v.sort(); 7 | let mut ans = ((v[0] + v[1]) as f64) / 2.0; 8 | for i in 2..n { 9 | ans = (ans + v[i] as f64) / 2.0; 10 | } 11 | println!("{}", ans); 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc143_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let d: Vec = sc.vec(n); 6 | let mut sum = 0; 7 | for i in 0..n { 8 | for j in (i + 1)..n { 9 | sum += d[i] * d[j]; 10 | } 11 | } 12 | println!("{}", sum); 13 | } 14 | 15 | pub struct Scanner { 16 | stdin: R, 17 | } 18 | 19 | impl Scanner { 20 | pub fn read(&mut self) -> T { 21 | use std::io::Read; 22 | let buf = self 23 | .stdin 24 | .by_ref() 25 | .bytes() 26 | .map(|b| b.unwrap()) 27 | .skip_while(|&b| b == b' ' || b == b'\n') 28 | .take_while(|&b| b != b' ' && b != b'\n') 29 | .collect::>(); 30 | unsafe { std::str::from_utf8_unchecked(&buf) } 31 | .parse() 32 | .ok() 33 | .expect("Parse error.") 34 | } 35 | pub fn vec(&mut self, n: usize) -> Vec { 36 | (0..n).map(|_| self.read()).collect() 37 | } 38 | pub fn chars(&mut self) -> Vec { 39 | self.read::().chars().collect() 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /atcoder/abc136_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: u64 = sc.read(); 5 | let mut ans = 0; 6 | for i in 1..(n + 1) { 7 | if 1 <= i && i <= 9 || 100 <= i && i <= 999 || 10000 <= i && i <= 99999 { 8 | ans += 1; 9 | } 10 | } 11 | println!("{}", ans); 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc138_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let a: Vec = sc.vec(n); 6 | let all = a.iter().fold(1.0, |p, e| p * *e); 7 | let mut sum = 0.0; 8 | for i in 0..n { 9 | sum += all / a[i]; 10 | } 11 | println!("{}", all / sum); 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n') 27 | .take_while(|&b| b != b' ' && b != b'\n') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc142_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let k: usize = sc.read(); 6 | let mut count = 0; 7 | for _ in 0..n { 8 | let h: usize = sc.read(); 9 | if h >= k { 10 | count += 1; 11 | } 12 | } 13 | println!("{}", count); 14 | } 15 | 16 | pub struct Scanner { 17 | stdin: R, 18 | } 19 | 20 | impl Scanner { 21 | pub fn read(&mut self) -> T { 22 | use std::io::Read; 23 | let buf = self 24 | .stdin 25 | .by_ref() 26 | .bytes() 27 | .map(|b| b.unwrap()) 28 | .skip_while(|&b| b == b' ' || b == b'\n') 29 | .take_while(|&b| b != b' ' && b != b'\n') 30 | .collect::>(); 31 | unsafe { std::str::from_utf8_unchecked(&buf) } 32 | .parse() 33 | .ok() 34 | .expect("Parse error.") 35 | } 36 | pub fn vec(&mut self, n: usize) -> Vec { 37 | (0..n).map(|_| self.read()).collect() 38 | } 39 | pub fn chars(&mut self) -> Vec { 40 | self.read::().chars().collect() 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /atcoder/abc130_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let w: f64 = sc.read(); 5 | let h: f64 = sc.read(); 6 | let x: f64 = sc.read(); 7 | let y: f64 = sc.read(); 8 | let s = w * h; 9 | println!( 10 | "{} {}", 11 | s / 2.0, 12 | if x * 2.0 == w && y * 2.0 == h { 1 } else { 0 } 13 | ); 14 | } 15 | 16 | pub struct Scanner { 17 | stdin: R, 18 | } 19 | 20 | impl Scanner { 21 | pub fn read(&mut self) -> T { 22 | use std::io::Read; 23 | let buf = self 24 | .stdin 25 | .by_ref() 26 | .bytes() 27 | .map(|b| b.unwrap()) 28 | .skip_while(|&b| b == b' ' || b == b'\n') 29 | .take_while(|&b| b != b' ' && b != b'\n') 30 | .collect::>(); 31 | unsafe { std::str::from_utf8_unchecked(&buf) } 32 | .parse() 33 | .ok() 34 | .expect("Parse error.") 35 | } 36 | pub fn vec(&mut self, n: usize) -> Vec { 37 | (0..n).map(|_| self.read()).collect() 38 | } 39 | pub fn chars(&mut self) -> Vec { 40 | self.read::().chars().collect() 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /atcoder/abc137_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let k: i64 = sc.read(); 5 | let x: i64 = sc.read(); 6 | let start = x - k + 1; 7 | let end = x + k - 1; 8 | for i in start..(end + 1) { 9 | if i > start { 10 | print!(" "); 11 | } 12 | print!("{}", i); 13 | } 14 | println!(); 15 | } 16 | 17 | pub struct Scanner { 18 | stdin: R, 19 | } 20 | 21 | impl Scanner { 22 | pub fn read(&mut self) -> T { 23 | use std::io::Read; 24 | let buf = self 25 | .stdin 26 | .by_ref() 27 | .bytes() 28 | .map(|b| b.unwrap()) 29 | .skip_while(|&b| b == b' ' || b == b'\n') 30 | .take_while(|&b| b != b' ' && b != b'\n') 31 | .collect::>(); 32 | unsafe { std::str::from_utf8_unchecked(&buf) } 33 | .parse() 34 | .ok() 35 | .expect("Parse error.") 36 | } 37 | pub fn vec(&mut self, n: usize) -> Vec { 38 | (0..n).map(|_| self.read()).collect() 39 | } 40 | pub fn chars(&mut self) -> Vec { 41 | self.read::().chars().collect() 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /atcoder/abc144_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let n: u64 = sc.read(); 8 | let mut ans = n; 9 | for i in 1..1000001 { 10 | if n % i == 0 { 11 | let j = n / i; 12 | ans = cmp::min(ans, i - 1 + j - 1); 13 | } 14 | } 15 | 16 | println!("{}", ans); 17 | } 18 | 19 | pub struct Scanner { 20 | stdin: R, 21 | } 22 | 23 | impl Scanner { 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .stdin 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n') 32 | .take_while(|&b| b != b' ' && b != b'\n') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/abc127_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: usize = sc.read(); 5 | let b: usize = sc.read(); 6 | println!( 7 | "{}", 8 | if a >= 13 { 9 | b 10 | } else if a >= 6 { 11 | b / 2 12 | } else { 13 | 0 14 | } 15 | ); 16 | } 17 | 18 | pub struct Scanner { 19 | stdin: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .stdin 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 31 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/abc128_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut v = (0..n) 6 | .map(|i| (sc.read::(), -sc.read::(), i)) 7 | .collect::>(); 8 | v.sort(); 9 | for (_, _, i) in v.into_iter() { 10 | println!("{}", i + 1); 11 | } 12 | } 13 | 14 | pub struct Scanner { 15 | stdin: R, 16 | } 17 | 18 | impl Scanner { 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .stdin 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 27 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc130_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let x: u64 = sc.read(); 6 | let l: Vec = sc.vec(n); 7 | let mut d = 0; 8 | let mut ans = 1; 9 | for l in l.into_iter() { 10 | d = d + l; 11 | if d <= x { 12 | ans += 1; 13 | } 14 | } 15 | println!("{}", ans); 16 | } 17 | 18 | pub struct Scanner { 19 | stdin: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .stdin 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n') 31 | .take_while(|&b| b != b' ' && b != b'\n') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/abc132_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let p: Vec = sc.vec(n); 6 | let mut ans = 0; 7 | for i in 1..(n - 1) { 8 | let mut v = vec![p[i - 1], p[i], p[i + 1]]; 9 | v.sort(); 10 | if v[1] == p[i] { 11 | ans += 1; 12 | } 13 | } 14 | println!("{}", ans); 15 | } 16 | 17 | pub struct Scanner { 18 | stdin: R, 19 | } 20 | 21 | impl Scanner { 22 | pub fn read(&mut self) -> T { 23 | use std::io::Read; 24 | let buf = self 25 | .stdin 26 | .by_ref() 27 | .bytes() 28 | .map(|b| b.unwrap()) 29 | .skip_while(|&b| b == b' ' || b == b'\n') 30 | .take_while(|&b| b != b' ' && b != b'\n') 31 | .collect::>(); 32 | unsafe { std::str::from_utf8_unchecked(&buf) } 33 | .parse() 34 | .ok() 35 | .expect("Parse error.") 36 | } 37 | pub fn vec(&mut self, n: usize) -> Vec { 38 | (0..n).map(|_| self.read()).collect() 39 | } 40 | pub fn chars(&mut self) -> Vec { 41 | self.read::().chars().collect() 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /atcoder/abc135_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let p: Vec = sc.vec(n); 6 | let mut count = 0; 7 | for i in 0..n { 8 | if p[i] != i + 1 { 9 | count += 1; 10 | } 11 | } 12 | if count <= 2 { 13 | println!("YES"); 14 | } else { 15 | println!("NO"); 16 | } 17 | } 18 | 19 | pub struct Scanner { 20 | stdin: R, 21 | } 22 | 23 | impl Scanner { 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .stdin 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n') 32 | .take_while(|&b| b != b' ' && b != b'\n') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/abc136_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n = sc.read(); 5 | let mut h: Vec = sc.vec(n); 6 | for i in (0..(n - 1)).rev() { 7 | if h[i] > h[i + 1] { 8 | h[i] -= 1; 9 | } 10 | if h[i] > h[i + 1] { 11 | println!("No"); 12 | return; 13 | } 14 | } 15 | println!("Yes"); 16 | } 17 | 18 | pub struct Scanner { 19 | stdin: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .stdin 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n') 31 | .take_while(|&b| b != b' ' && b != b'\n') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/agc029_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { reader: s.lock() }; 4 | let s = sc.chars(); 5 | let n = s.len(); 6 | let mut ans = 0; 7 | let mut white = 0; 8 | for i in 0..n { 9 | if s[i] == 'W' { 10 | assert!(i >= white); 11 | ans += i - white; 12 | white += 1; 13 | } 14 | } 15 | println!("{}", ans); 16 | } 17 | 18 | pub struct Scanner { 19 | reader: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .reader 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n') 31 | .take_while(|&b| b != b' ' && b != b'\n') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn read_vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/tkppc4_2_g.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | } 5 | // a1 a2 a3 a4 a5 6 | // a1 = x 7 | // a2 = y + 4x 8 | // a3 = z + 4y + 9z 9 | // a4 = w + 4z + 9y + 16x 10 | // a5 = v + 4w + 9z + 16y + 25x 11 | 12 | // b1 = a2 - a1 = y + 3x 13 | // b2 = z + 3y + 5x 14 | // b3 = w + 3z + 5y + 7x 15 | // b4 = v + 3w + 5z + 7y + 9x 16 | 17 | // c1 = z + 2y + 2x 18 | // c2 = w + 2z + 2y + 2x 19 | 20 | pub struct Scanner { 21 | stdin: R, 22 | } 23 | 24 | impl Scanner { 25 | pub fn read(&mut self) -> T { 26 | use std::io::Read; 27 | let buf = self 28 | .stdin 29 | .by_ref() 30 | .bytes() 31 | .map(|b| b.unwrap()) 32 | .skip_while(|&b| b == b' ' || b == b'\n') 33 | .take_while(|&b| b != b' ' && b != b'\n') 34 | .collect::>(); 35 | unsafe { std::str::from_utf8_unchecked(&buf) } 36 | .parse() 37 | .ok() 38 | .expect("Parse error.") 39 | } 40 | pub fn vec(&mut self, n: usize) -> Vec { 41 | (0..n).map(|_| self.read()).collect() 42 | } 43 | pub fn chars(&mut self) -> Vec { 44 | self.read::().chars().collect() 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /atcoder/arc082_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n = sc.read(); 5 | let mut a: Vec = sc.vec(n); 6 | let mut count = 0; 7 | for i in 1..n { 8 | if a[i - 1] == i { 9 | count += 1; 10 | a.swap(i - 1, i); 11 | } 12 | } 13 | if a[n - 1] == n { 14 | count += 1; 15 | } 16 | println!("{}", count); 17 | } 18 | 19 | pub struct Scanner { 20 | stdin: R, 21 | } 22 | 23 | impl Scanner { 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .stdin 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n') 32 | .take_while(|&b| b != b' ' && b != b'\n') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/tkppc4_2_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let x: i64 = sc.read(); 5 | let y: i64 = sc.read(); 6 | if y < 0 || y % 2 != 0 { 7 | println!("-1"); 8 | } else { 9 | let y_step = y / 2; 10 | if x.abs() % 2 != y_step % 2 || x.abs() > y_step { 11 | println!("-1"); 12 | } else { 13 | println!("{}", y_step); 14 | } 15 | } 16 | } 17 | 18 | pub struct Scanner { 19 | stdin: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .stdin 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n') 31 | .take_while(|&b| b != b' ' && b != b'\n') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/abc139_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp::max; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let mut cur = 1; 9 | let mut ans = 1; 10 | for i in 1..n { 11 | if a[i - 1] < a[i] { 12 | cur = 1; 13 | } else { 14 | cur += 1; 15 | } 16 | ans = max(ans, cur); 17 | } 18 | println!("{}", ans - 1); 19 | } 20 | 21 | pub struct Scanner { 22 | stdin: R, 23 | } 24 | 25 | impl Scanner { 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .stdin 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n') 34 | .take_while(|&b| b != b' ' && b != b'\n') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/arc097_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | } 5 | 6 | pub struct IO(R, std::io::BufWriter); 7 | 8 | impl IO { 9 | pub fn new(r: R, w: W) -> IO { 10 | IO(r, std::io::BufWriter::new(w)) 11 | } 12 | pub fn write>(&mut self, s: S) { 13 | use std::io::Write; 14 | self.1.write(s.as_bytes()).unwrap(); 15 | } 16 | pub fn read(&mut self) -> T { 17 | use std::io::Read; 18 | let buf = self 19 | .0 20 | .by_ref() 21 | .bytes() 22 | .map(|b| b.unwrap()) 23 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 24 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 25 | .collect::>(); 26 | unsafe { std::str::from_utf8_unchecked(&buf) } 27 | .parse() 28 | .ok() 29 | .expect("Parse error.") 30 | } 31 | pub fn vec(&mut self, n: usize) -> Vec { 32 | (0..n).map(|_| self.read()).collect() 33 | } 34 | pub fn chars(&mut self) -> Vec { 35 | self.read::().chars().collect() 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /atcoder/abc126_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let k: usize = sc.read(); 6 | let s = sc.chars(); 7 | for i in 0..n { 8 | if i + 1 == k { 9 | let c = s[i] as u8 - 'A' as u8; 10 | let d = ('a' as u8 + c) as char; 11 | print!("{}", d); 12 | } else { 13 | print!("{}", s[i]); 14 | } 15 | } 16 | } 17 | 18 | pub struct Scanner { 19 | stdin: R, 20 | } 21 | 22 | impl Scanner { 23 | pub fn read(&mut self) -> T { 24 | use std::io::Read; 25 | let buf = self 26 | .stdin 27 | .by_ref() 28 | .bytes() 29 | .map(|b| b.unwrap()) 30 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 31 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 32 | .collect::>(); 33 | unsafe { std::str::from_utf8_unchecked(&buf) } 34 | .parse() 35 | .ok() 36 | .expect("Parse error.") 37 | } 38 | pub fn vec(&mut self, n: usize) -> Vec { 39 | (0..n).map(|_| self.read()).collect() 40 | } 41 | pub fn chars(&mut self) -> Vec { 42 | self.read::().chars().collect() 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /atcoder/abc126_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let k: usize = sc.read(); 6 | let mut ans: Vec = vec![1.0; n]; 7 | for i in 0..n { 8 | let mut point = i + 1; 9 | while point < k { 10 | point *= 2; 11 | ans[i] /= 2.0; 12 | } 13 | } 14 | 15 | let ans = ans.into_iter().sum::() / (n as f64); 16 | println!("{}", ans); 17 | } 18 | 19 | pub struct Scanner { 20 | stdin: R, 21 | } 22 | 23 | impl Scanner { 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .stdin 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 32 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/abc126_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let x: usize = sc.read(); 5 | let y = x / 100; 6 | let m = x % 100; 7 | let yymm = 1 <= m && m <= 12; 8 | let mmyy = 1 <= y && y <= 12; 9 | if yymm && mmyy { 10 | println!("AMBIGUOUS"); 11 | } else if yymm { 12 | println!("YYMM"); 13 | } else if mmyy { 14 | println!("MMYY"); 15 | } else { 16 | println!("NA"); 17 | } 18 | } 19 | 20 | pub struct Scanner { 21 | stdin: R, 22 | } 23 | 24 | impl Scanner { 25 | pub fn read(&mut self) -> T { 26 | use std::io::Read; 27 | let buf = self 28 | .stdin 29 | .by_ref() 30 | .bytes() 31 | .map(|b| b.unwrap()) 32 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 33 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 34 | .collect::>(); 35 | unsafe { std::str::from_utf8_unchecked(&buf) } 36 | .parse() 37 | .ok() 38 | .expect("Parse error.") 39 | } 40 | pub fn vec(&mut self, n: usize) -> Vec { 41 | (0..n).map(|_| self.read()).collect() 42 | } 43 | pub fn chars(&mut self) -> Vec { 44 | self.read::().chars().collect() 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /atcoder/abc142_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let a: Vec = sc.vec(n); 6 | let mut b = a 7 | .into_iter() 8 | .enumerate() 9 | .map(|(i, a)| (a, i + 1)) 10 | .collect::>(); 11 | b.sort(); 12 | for (i, (_, x)) in b.into_iter().enumerate() { 13 | if i > 0 { 14 | print!(" "); 15 | } 16 | print!("{}", x); 17 | } 18 | println!(); 19 | } 20 | 21 | pub struct Scanner { 22 | stdin: R, 23 | } 24 | 25 | impl Scanner { 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .stdin 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n') 34 | .take_while(|&b| b != b' ' && b != b'\n') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/abc127_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: u64 = sc.read(); 7 | let m: usize = sc.read(); 8 | let mut min: u64 = 1; 9 | let mut max: u64 = n; 10 | for _ in 0..m { 11 | min = cmp::max(min, sc.read()); 12 | max = cmp::min(max, sc.read()); 13 | } 14 | if min > max { 15 | println!("0"); 16 | } else { 17 | println!("{}", max - min + 1); 18 | } 19 | } 20 | 21 | pub struct Scanner { 22 | stdin: R, 23 | } 24 | 25 | impl Scanner { 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .stdin 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 34 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/tkppc4_1_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | 5 | let n: usize = sc.read(); 6 | let k: u32 = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let mut ans: Option = None; 9 | for i in 0..n { 10 | if a[i] < k { 11 | ans = ans.or(Some(i)).map(|j| if a[i] > a[j] { i } else { j }); 12 | } 13 | } 14 | 15 | match ans { 16 | Some(i) => println!("{}", i + 1), 17 | None => println!("-1"), 18 | } 19 | } 20 | 21 | pub struct Scanner { 22 | stdin: R, 23 | } 24 | 25 | impl Scanner { 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .stdin 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n') 34 | .take_while(|&b| b != b' ' && b != b'\n') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/cf17_final_a.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | fn main() { 4 | let labels = (0..(1 << 4)).map(|mask| { 5 | let mut label = "".to_owned(); 6 | if ((1 << 0) & mask) != 0 { 7 | label.push('A'); 8 | } 9 | label.push('K'); 10 | label.push('I'); 11 | label.push('H'); 12 | if ((1 << 1) & mask) != 0 { 13 | label.push('A'); 14 | } 15 | label.push('B'); 16 | if ((1 << 2) & mask) != 0 { 17 | label.push('A'); 18 | } 19 | label.push('R'); 20 | if ((1 << 3) & mask) != 0 { 21 | label.push('A'); 22 | } 23 | label 24 | }).collect::>(); 25 | 26 | let s = read_line().trim().to_owned(); 27 | 28 | if labels.contains(&s) { 29 | println!("YES"); 30 | } else { 31 | println!("NO"); 32 | } 33 | } 34 | 35 | fn read_line() -> String { 36 | let stdin = io::stdin(); 37 | let mut buf = String::new(); 38 | stdin.read_line(&mut buf).unwrap(); 39 | buf 40 | } 41 | 42 | fn read() -> T 43 | where T: std::str::FromStr, 44 | T::Err: std::fmt::Debug 45 | { 46 | read_line().trim().parse().unwrap() 47 | } 48 | 49 | fn read_values() -> Vec 50 | where T: std::str::FromStr, 51 | T::Err: std::fmt::Debug 52 | { 53 | read_line() 54 | .split(' ') 55 | .map(|a| a.trim().parse().unwrap()) 56 | .collect() 57 | } -------------------------------------------------------------------------------- /atcoder/tkppc4_1_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: u64 = sc.read(); 5 | let x: Vec = sc 6 | .read::() 7 | .chars() 8 | .map(|c| c as u64 - '0' as u64) 9 | .collect(); 10 | let max = *x.iter().max().unwrap(); 11 | for m in (max + 1)..11 { 12 | let sum = x.iter().fold(0, |sum, &x| sum * m + x); 13 | if sum == n { 14 | println!("{}", m); 15 | return; 16 | } 17 | } 18 | } 19 | 20 | pub struct Scanner { 21 | stdin: R, 22 | } 23 | 24 | impl Scanner { 25 | pub fn read(&mut self) -> T { 26 | use std::io::Read; 27 | let buf = self 28 | .stdin 29 | .by_ref() 30 | .bytes() 31 | .map(|b| b.unwrap()) 32 | .skip_while(|&b| b == b' ' || b == b'\n') 33 | .take_while(|&b| b != b' ' && b != b'\n') 34 | .collect::>(); 35 | unsafe { std::str::from_utf8_unchecked(&buf) } 36 | .parse() 37 | .ok() 38 | .expect("Parse error.") 39 | } 40 | pub fn vec(&mut self, n: usize) -> Vec { 41 | (0..n).map(|_| self.read()).collect() 42 | } 43 | pub fn chars(&mut self) -> Vec { 44 | self.read::().chars().collect() 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /atcoder/abc135_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let mut a: Vec = sc.vec(n + 1); 8 | let b: Vec = sc.vec(n); 9 | let mut ans = 0; 10 | for i in 0..n { 11 | let prev = cmp::min(a[i], b[i]); 12 | ans += prev; 13 | let remain = b[i] - prev; 14 | 15 | let next = cmp::min(remain, a[i + 1]); 16 | a[i + 1] -= next; 17 | ans += next; 18 | } 19 | println!("{}", ans); 20 | } 21 | 22 | pub struct Scanner { 23 | stdin: R, 24 | } 25 | 26 | impl Scanner { 27 | pub fn read(&mut self) -> T { 28 | use std::io::Read; 29 | let buf = self 30 | .stdin 31 | .by_ref() 32 | .bytes() 33 | .map(|b| b.unwrap()) 34 | .skip_while(|&b| b == b' ' || b == b'\n') 35 | .take_while(|&b| b != b' ' && b != b'\n') 36 | .collect::>(); 37 | unsafe { std::str::from_utf8_unchecked(&buf) } 38 | .parse() 39 | .ok() 40 | .expect("Parse error.") 41 | } 42 | pub fn vec(&mut self, n: usize) -> Vec { 43 | (0..n).map(|_| self.read()).collect() 44 | } 45 | pub fn chars(&mut self) -> Vec { 46 | self.read::().chars().collect() 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /atcoder/arc094_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let mut sum = 0; 8 | let mut min = std::i64::MAX; 9 | for _ in 0..n { 10 | let a: i64 = sc.read(); 11 | let b: i64 = sc.read(); 12 | sum += a; 13 | if a > b { 14 | min = cmp::min(min, b); 15 | } 16 | } 17 | if min == std::i64::MAX { 18 | println!("0"); 19 | } else { 20 | println!("{}", sum - min); 21 | } 22 | } 23 | 24 | pub struct Scanner { 25 | stdin: R, 26 | } 27 | 28 | impl Scanner { 29 | pub fn read(&mut self) -> T { 30 | use std::io::Read; 31 | let buf = self 32 | .stdin 33 | .by_ref() 34 | .bytes() 35 | .map(|b| b.unwrap()) 36 | .skip_while(|&b| b == b' ' || b == b'\n') 37 | .take_while(|&b| b != b' ' && b != b'\n') 38 | .collect::>(); 39 | unsafe { std::str::from_utf8_unchecked(&buf) } 40 | .parse() 41 | .ok() 42 | .expect("Parse error.") 43 | } 44 | pub fn vec(&mut self, n: usize) -> Vec { 45 | (0..n).map(|_| self.read()).collect() 46 | } 47 | pub fn chars(&mut self) -> Vec { 48 | self.read::().chars().collect() 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /atcoder/jsc2019_qual_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let m: u64 = sc.read(); 5 | let d: u64 = sc.read(); 6 | let mut ans = 0; 7 | for m in 1..(m + 1) { 8 | for d in 1..(d + 1) { 9 | if d >= 10 { 10 | let d1 = d % 10; 11 | let d10 = d / 10; 12 | if d1 >= 2 && d10 >= 2 && d1 * d10 == m { 13 | ans += 1; 14 | } 15 | } 16 | } 17 | } 18 | println!("{}", ans); 19 | } 20 | 21 | pub struct Scanner { 22 | stdin: R, 23 | } 24 | 25 | impl Scanner { 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .stdin 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n') 34 | .take_while(|&b| b != b' ' && b != b'\n') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/past201912_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let mut a: Vec = sc.vec(6); 5 | a.sort(); 6 | println!("{}", a[3]); 7 | } 8 | 9 | pub struct IO(R, std::io::BufWriter); 10 | 11 | impl IO { 12 | pub fn new(r: R, w: W) -> IO { 13 | IO(r, std::io::BufWriter::new(w)) 14 | } 15 | pub fn write>(&mut self, s: S) { 16 | use std::io::Write; 17 | self.1.write(s.as_bytes()).unwrap(); 18 | } 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .0 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 27 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/tkppc4_2_h.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n = sc.read(); 5 | let k: usize = sc.read(); 6 | let mut a: Vec = sc.vec(n); 7 | a.sort(); 8 | // p/(1-p)^2 9 | 10 | let mut ans = 0.0; 11 | for i in 0..k { 12 | let from = a[i] as f64; 13 | let to = a[n - k + i] as f64; 14 | let p = from / (from + to); 15 | let q = to / (from + to); 16 | let sum = q / (1.0 - p) / (1.0 - p); 17 | ans += sum; 18 | } 19 | println!("{}", ans); 20 | } 21 | 22 | pub struct Scanner { 23 | stdin: R, 24 | } 25 | 26 | impl Scanner { 27 | pub fn read(&mut self) -> T { 28 | use std::io::Read; 29 | let buf = self 30 | .stdin 31 | .by_ref() 32 | .bytes() 33 | .map(|b| b.unwrap()) 34 | .skip_while(|&b| b == b' ' || b == b'\n') 35 | .take_while(|&b| b != b' ' && b != b'\n') 36 | .collect::>(); 37 | unsafe { std::str::from_utf8_unchecked(&buf) } 38 | .parse() 39 | .ok() 40 | .expect("Parse error.") 41 | } 42 | pub fn vec(&mut self, n: usize) -> Vec { 43 | (0..n).map(|_| self.read()).collect() 44 | } 45 | pub fn chars(&mut self) -> Vec { 46 | self.read::().chars().collect() 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /atcoder/abc149_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let s: String = sc.read(); 5 | let t: String = sc.read(); 6 | println!("{}{}", t, s); 7 | } 8 | 9 | pub struct IO(R, std::io::BufWriter); 10 | 11 | impl IO { 12 | pub fn new(r: R, w: W) -> IO { 13 | IO(r, std::io::BufWriter::new(w)) 14 | } 15 | pub fn write>(&mut self, s: S) { 16 | use std::io::Write; 17 | self.1.write(s.as_bytes()).unwrap(); 18 | } 19 | pub fn read(&mut self) -> T { 20 | use std::io::Read; 21 | let buf = self 22 | .0 23 | .by_ref() 24 | .bytes() 25 | .map(|b| b.unwrap()) 26 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 27 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 28 | .collect::>(); 29 | unsafe { std::str::from_utf8_unchecked(&buf) } 30 | .parse() 31 | .ok() 32 | .expect("Parse error.") 33 | } 34 | pub fn vec(&mut self, n: usize) -> Vec { 35 | (0..n).map(|_| self.read()).collect() 36 | } 37 | pub fn chars(&mut self) -> Vec { 38 | self.read::().chars().collect() 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /atcoder/abc133_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | const INF: u64 = std::u64::MAX; 4 | 5 | fn main() { 6 | let s = std::io::stdin(); 7 | let mut sc = Scanner { stdin: s.lock() }; 8 | let l: u64 = sc.read(); 9 | let r: u64 = sc.read(); 10 | if r - l > 10000 { 11 | println!("0"); 12 | } else { 13 | let mut ans = INF; 14 | for i in l..(r + 1) { 15 | for j in (i + 1)..(r + 1) { 16 | ans = cmp::min(ans, (i * j) % 2019); 17 | } 18 | } 19 | 20 | assert_ne!(ans, INF); 21 | println!("{}", ans); 22 | } 23 | } 24 | 25 | pub struct Scanner { 26 | stdin: R, 27 | } 28 | 29 | impl Scanner { 30 | pub fn read(&mut self) -> T { 31 | use std::io::Read; 32 | let buf = self 33 | .stdin 34 | .by_ref() 35 | .bytes() 36 | .map(|b| b.unwrap()) 37 | .skip_while(|&b| b == b' ' || b == b'\n') 38 | .take_while(|&b| b != b' ' && b != b'\n') 39 | .collect::>(); 40 | unsafe { std::str::from_utf8_unchecked(&buf) } 41 | .parse() 42 | .ok() 43 | .expect("Parse error.") 44 | } 45 | pub fn vec(&mut self, n: usize) -> Vec { 46 | (0..n).map(|_| self.read()).collect() 47 | } 48 | pub fn chars(&mut self) -> Vec { 49 | self.read::().chars().collect() 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /atcoder/abc137_c.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeMap; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let mut map = BTreeMap::new(); 8 | for _ in 0..n { 9 | let mut s = sc.read::().bytes().collect::>(); 10 | s.sort(); 11 | let s = String::from_utf8(s).unwrap(); 12 | *map.entry(s).or_insert(0) += 1; 13 | } 14 | 15 | let mut ans: u64 = 0; 16 | for (_, c) in map.into_iter() { 17 | ans += c * (c - 1) / 2; 18 | } 19 | println!("{}", ans); 20 | } 21 | 22 | pub struct Scanner { 23 | stdin: R, 24 | } 25 | 26 | impl Scanner { 27 | pub fn read(&mut self) -> T { 28 | use std::io::Read; 29 | let buf = self 30 | .stdin 31 | .by_ref() 32 | .bytes() 33 | .map(|b| b.unwrap()) 34 | .skip_while(|&b| b == b' ' || b == b'\n') 35 | .take_while(|&b| b != b' ' && b != b'\n') 36 | .collect::>(); 37 | unsafe { std::str::from_utf8_unchecked(&buf) } 38 | .parse() 39 | .ok() 40 | .expect("Parse error.") 41 | } 42 | pub fn vec(&mut self, n: usize) -> Vec { 43 | (0..n).map(|_| self.read()).collect() 44 | } 45 | pub fn chars(&mut self) -> Vec { 46 | self.read::().chars().collect() 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /atcoder/abc134_e.rs: -------------------------------------------------------------------------------- 1 | const INF: u64 = 1e10 as u64; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let mut dp = vec![INF; n]; 9 | dp[0] = a[n - 1]; 10 | for a in a.into_iter().rev().skip(1) { 11 | let i = dp 12 | .binary_search_by_key(&(a * 2 + 1), |&b| b * 2) 13 | .err() 14 | .unwrap(); 15 | dp[i] = a; 16 | } 17 | 18 | let ans = dp.into_iter().take_while(|&i| i != INF).count(); 19 | println!("{}", ans); 20 | } 21 | 22 | pub struct Scanner { 23 | stdin: R, 24 | } 25 | 26 | impl Scanner { 27 | pub fn read(&mut self) -> T { 28 | use std::io::Read; 29 | let buf = self 30 | .stdin 31 | .by_ref() 32 | .bytes() 33 | .map(|b| b.unwrap()) 34 | .skip_while(|&b| b == b' ' || b == b'\n') 35 | .take_while(|&b| b != b' ' && b != b'\n') 36 | .collect::>(); 37 | unsafe { std::str::from_utf8_unchecked(&buf) } 38 | .parse() 39 | .ok() 40 | .expect("Parse error.") 41 | } 42 | pub fn vec(&mut self, n: usize) -> Vec { 43 | (0..n).map(|_| self.read()).collect() 44 | } 45 | pub fn chars(&mut self) -> Vec { 46 | self.read::().chars().collect() 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /atcoder/mujin_pc_2017_a.rs: -------------------------------------------------------------------------------- 1 | const MOD: usize = 1e9 as usize + 7; 2 | fn main() { 3 | let s = std::io::stdin(); 4 | let mut sc = Scanner { stdin: s.lock() }; 5 | let n: usize = sc.read(); 6 | let x: Vec = sc.vec(n); 7 | 8 | let mut stack = 0; 9 | let mut cur = 1; 10 | for x in x.into_iter() { 11 | if x < 2 * stack + 1 { 12 | cur *= stack + 1; 13 | cur %= MOD; 14 | } else { 15 | stack += 1; 16 | } 17 | } 18 | for i in 0..stack { 19 | cur *= i + 1; 20 | cur %= MOD; 21 | } 22 | println!("{}", cur); 23 | } 24 | 25 | pub struct Scanner { 26 | stdin: R, 27 | } 28 | 29 | impl Scanner { 30 | pub fn read(&mut self) -> T { 31 | use std::io::Read; 32 | let buf = self 33 | .stdin 34 | .by_ref() 35 | .bytes() 36 | .map(|b| b.unwrap()) 37 | .skip_while(|&b| b == b' ' || b == b'\n') 38 | .take_while(|&b| b != b' ' && b != b'\n') 39 | .collect::>(); 40 | unsafe { std::str::from_utf8_unchecked(&buf) } 41 | .parse() 42 | .ok() 43 | .expect("Parse error.") 44 | } 45 | pub fn vec(&mut self, n: usize) -> Vec { 46 | (0..n).map(|_| self.read()).collect() 47 | } 48 | pub fn chars(&mut self) -> Vec { 49 | self.read::().chars().collect() 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /atcoder/abc133_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let a: Vec = sc.vec(n); 6 | let sum: u64 = a.iter().sum(); 7 | let mut sum = sum / 2; 8 | for i in 0..(n - 1) { 9 | if i % 2 == 0 { 10 | sum -= a[i]; 11 | } 12 | } 13 | let mut ans = vec![0; n]; 14 | ans[0] = a[n - 1] - sum; 15 | for i in 1..n { 16 | ans[i] = a[(i + n - 1) % n] - ans[i - 1]; 17 | } 18 | 19 | for ans in ans.into_iter() { 20 | print!("{} ", ans * 2); 21 | } 22 | println!(); 23 | } 24 | 25 | pub struct Scanner { 26 | stdin: R, 27 | } 28 | 29 | impl Scanner { 30 | pub fn read(&mut self) -> T { 31 | use std::io::Read; 32 | let buf = self 33 | .stdin 34 | .by_ref() 35 | .bytes() 36 | .map(|b| b.unwrap()) 37 | .skip_while(|&b| b == b' ' || b == b'\n') 38 | .take_while(|&b| b != b' ' && b != b'\n') 39 | .collect::>(); 40 | unsafe { std::str::from_utf8_unchecked(&buf) } 41 | .parse() 42 | .ok() 43 | .expect("Parse error.") 44 | } 45 | pub fn vec(&mut self, n: usize) -> Vec { 46 | (0..n).map(|_| self.read()).collect() 47 | } 48 | pub fn chars(&mut self) -> Vec { 49 | self.read::().chars().collect() 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /atcoder/tenka1_2017_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: u64 = sc.read(); 5 | 6 | for h in 1..3501 { 7 | for w in 1..3501 { 8 | // 4/n - 1/h - 1/w = 4*h*w - w*n - h*n 9 | if 4 * h * w < w * n + h * n { 10 | continue; 11 | } 12 | let a = 4 * h * w - w * n - h * n; 13 | let b = h * n * w; 14 | if a > 0 && b % a == 0 { 15 | println!("{} {} {}", b / a, w, h); 16 | return; 17 | } 18 | } 19 | } 20 | unreachable!() 21 | } 22 | 23 | pub struct Scanner { 24 | stdin: R, 25 | } 26 | 27 | impl Scanner { 28 | pub fn read(&mut self) -> T { 29 | use std::io::Read; 30 | let buf = self 31 | .stdin 32 | .by_ref() 33 | .bytes() 34 | .map(|b| b.unwrap()) 35 | .skip_while(|&b| b == b' ' || b == b'\n') 36 | .take_while(|&b| b != b' ' && b != b'\n') 37 | .collect::>(); 38 | unsafe { std::str::from_utf8_unchecked(&buf) } 39 | .parse() 40 | .ok() 41 | .expect("Parse error.") 42 | } 43 | pub fn vec(&mut self, n: usize) -> Vec { 44 | (0..n).map(|_| self.read()).collect() 45 | } 46 | pub fn chars(&mut self) -> Vec { 47 | self.read::().chars().collect() 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /atcoder/past201912_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | 5 | let s = sc.read::(); 6 | match s.parse::() { 7 | Ok(a) => println!("{}", a * 2), 8 | Err(_) => println!("error"), 9 | } 10 | } 11 | 12 | pub struct IO(R, std::io::BufWriter); 13 | 14 | impl IO { 15 | pub fn new(r: R, w: W) -> IO { 16 | IO(r, std::io::BufWriter::new(w)) 17 | } 18 | pub fn write>(&mut self, s: S) { 19 | use std::io::Write; 20 | self.1.write(s.as_bytes()).unwrap(); 21 | } 22 | pub fn read(&mut self) -> T { 23 | use std::io::Read; 24 | let buf = self 25 | .0 26 | .by_ref() 27 | .bytes() 28 | .map(|b| b.unwrap()) 29 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 30 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 31 | .collect::>(); 32 | unsafe { std::str::from_utf8_unchecked(&buf) } 33 | .parse() 34 | .ok() 35 | .expect("Parse error.") 36 | } 37 | pub fn vec(&mut self, n: usize) -> Vec { 38 | (0..n).map(|_| self.read()).collect() 39 | } 40 | pub fn chars(&mut self) -> Vec { 41 | self.read::().chars().collect() 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /atcoder/abc150_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | 5 | let k: usize = sc.read(); 6 | let x: usize = sc.read(); 7 | if k * 500 >= x { 8 | println!("Yes"); 9 | } else { 10 | println!("No"); 11 | } 12 | } 13 | 14 | pub struct IO(R, std::io::BufWriter); 15 | 16 | impl IO { 17 | pub fn new(r: R, w: W) -> IO { 18 | IO(r, std::io::BufWriter::new(w)) 19 | } 20 | pub fn write>(&mut self, s: S) { 21 | use std::io::Write; 22 | self.1.write(s.as_bytes()).unwrap(); 23 | } 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .0 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 32 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/agc014_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut graph = vec![vec![]; n]; 6 | for _ in 1..n { 7 | let a = sc.read::() - 1; 8 | let b = sc.read::() - 1; 9 | graph[a].push(b); 10 | graph[b].push(a); 11 | } 12 | 13 | for i in 0..n { 14 | if graph[i] 15 | .iter() 16 | .filter(|&&child| graph[child].len() == 1) 17 | .count() 18 | >= 2 19 | { 20 | println!("First"); 21 | return; 22 | } 23 | } 24 | println!("Second"); 25 | } 26 | 27 | pub struct Scanner { 28 | stdin: R, 29 | } 30 | 31 | impl Scanner { 32 | pub fn read(&mut self) -> T { 33 | use std::io::Read; 34 | let buf = self 35 | .stdin 36 | .by_ref() 37 | .bytes() 38 | .map(|b| b.unwrap()) 39 | .skip_while(|&b| b == b' ' || b == b'\n') 40 | .take_while(|&b| b != b' ' && b != b'\n') 41 | .collect::>(); 42 | unsafe { std::str::from_utf8_unchecked(&buf) } 43 | .parse() 44 | .ok() 45 | .expect("Parse error.") 46 | } 47 | pub fn vec(&mut self, n: usize) -> Vec { 48 | (0..n).map(|_| self.read()).collect() 49 | } 50 | pub fn chars(&mut self) -> Vec { 51 | self.read::().chars().collect() 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /atcoder/agc038_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let h: usize = sc.read(); 5 | let w: usize = sc.read(); 6 | let a: usize = sc.read(); 7 | let b: usize = sc.read(); 8 | let mut ans = vec![vec![0; w]; h]; 9 | for i in 0..h { 10 | for j in 0..w { 11 | if i < b && j < a { 12 | ans[i][j] = 1; 13 | } 14 | if i >= b && j >= a { 15 | ans[i][j] = 1; 16 | } 17 | } 18 | } 19 | 20 | for i in 0..h { 21 | for j in 0..w { 22 | print!("{}", ans[i][j]); 23 | } 24 | println!(); 25 | } 26 | } 27 | 28 | pub struct Scanner { 29 | stdin: R, 30 | } 31 | 32 | impl Scanner { 33 | pub fn read(&mut self) -> T { 34 | use std::io::Read; 35 | let buf = self 36 | .stdin 37 | .by_ref() 38 | .bytes() 39 | .map(|b| b.unwrap()) 40 | .skip_while(|&b| b == b' ' || b == b'\n') 41 | .take_while(|&b| b != b' ' && b != b'\n') 42 | .collect::>(); 43 | unsafe { std::str::from_utf8_unchecked(&buf) } 44 | .parse() 45 | .ok() 46 | .expect("Parse error.") 47 | } 48 | pub fn vec(&mut self, n: usize) -> Vec { 49 | (0..n).map(|_| self.read()).collect() 50 | } 51 | pub fn chars(&mut self) -> Vec { 52 | self.read::().chars().collect() 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /atcoder/agc024_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | 5 | let n = sc.read(); 6 | let a: Vec = sc.vec(n); 7 | if a[0] != 0 { 8 | println!("-1"); 9 | return; 10 | } 11 | for i in 1..n { 12 | if a[i] > a[i - 1] + 1 { 13 | println!("-1"); 14 | return; 15 | } 16 | } 17 | 18 | let mut cur = 0; 19 | let mut ans = 0; 20 | for i in (1..n).rev() { 21 | if a[i] > cur { 22 | ans += a[i]; 23 | cur = a[i]; 24 | } 25 | if cur > 0 { 26 | cur -= 1; 27 | } 28 | } 29 | println!("{}", ans); 30 | } 31 | 32 | pub struct Scanner { 33 | stdin: R, 34 | } 35 | 36 | impl Scanner { 37 | pub fn read(&mut self) -> T { 38 | use std::io::Read; 39 | let buf = self 40 | .stdin 41 | .by_ref() 42 | .bytes() 43 | .map(|b| b.unwrap()) 44 | .skip_while(|&b| b == b' ' || b == b'\n') 45 | .take_while(|&b| b != b' ' && b != b'\n') 46 | .collect::>(); 47 | unsafe { std::str::from_utf8_unchecked(&buf) } 48 | .parse() 49 | .ok() 50 | .expect("Parse error.") 51 | } 52 | pub fn vec(&mut self, n: usize) -> Vec { 53 | (0..n).map(|_| self.read()).collect() 54 | } 55 | pub fn chars(&mut self) -> Vec { 56 | self.read::().chars().collect() 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /atcoder/abc133_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let d: usize = sc.read(); 6 | let x: Vec> = (0..n).map(|_| sc.vec(d)).collect(); 7 | 8 | let mut ans = 0; 9 | for i in 0..n { 10 | for j in 0..i { 11 | let mut dist2 = 0; 12 | for k in 0..d { 13 | let dx = x[i][k] - x[j][k]; 14 | dist2 += dx * dx; 15 | } 16 | 17 | let sq = (dist2 as f64).sqrt() as i64; 18 | if sq * sq == dist2 { 19 | ans += 1; 20 | } 21 | } 22 | } 23 | 24 | println!("{}", ans); 25 | } 26 | 27 | pub struct Scanner { 28 | stdin: R, 29 | } 30 | 31 | impl Scanner { 32 | pub fn read(&mut self) -> T { 33 | use std::io::Read; 34 | let buf = self 35 | .stdin 36 | .by_ref() 37 | .bytes() 38 | .map(|b| b.unwrap()) 39 | .skip_while(|&b| b == b' ' || b == b'\n') 40 | .take_while(|&b| b != b' ' && b != b'\n') 41 | .collect::>(); 42 | unsafe { std::str::from_utf8_unchecked(&buf) } 43 | .parse() 44 | .ok() 45 | .expect("Parse error.") 46 | } 47 | pub fn vec(&mut self, n: usize) -> Vec { 48 | (0..n).map(|_| self.read()).collect() 49 | } 50 | pub fn chars(&mut self) -> Vec { 51 | self.read::().chars().collect() 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /atcoder/keyence2020_a.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let (r, w) = (std::io::stdin(), std::io::stdout()); 5 | let mut sc = IO::new(r.lock(), w.lock()); 6 | let h: usize = sc.read(); 7 | let w: usize = sc.read(); 8 | let n: usize = sc.read(); 9 | let m = cmp::max(h, w); 10 | let ans = (n + m - 1) / m; 11 | println!("{}", ans); 12 | } 13 | 14 | pub struct IO(R, std::io::BufWriter); 15 | 16 | impl IO { 17 | pub fn new(r: R, w: W) -> IO { 18 | IO(r, std::io::BufWriter::new(w)) 19 | } 20 | pub fn write>(&mut self, s: S) { 21 | use std::io::Write; 22 | self.1.write(s.as_bytes()).unwrap(); 23 | } 24 | pub fn read(&mut self) -> T { 25 | use std::io::Read; 26 | let buf = self 27 | .0 28 | .by_ref() 29 | .bytes() 30 | .map(|b| b.unwrap()) 31 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 32 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 33 | .collect::>(); 34 | unsafe { std::str::from_utf8_unchecked(&buf) } 35 | .parse() 36 | .ok() 37 | .expect("Parse error.") 38 | } 39 | pub fn vec(&mut self, n: usize) -> Vec { 40 | (0..n).map(|_| self.read()).collect() 41 | } 42 | pub fn chars(&mut self) -> Vec { 43 | self.read::().chars().collect() 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /atcoder/abc150_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let n: usize = sc.read(); 5 | let s = sc.read::(); 6 | let mut ans = 0; 7 | for i in 2..n { 8 | if &s[(i - 2)..(i + 1)] == "ABC" { 9 | ans += 1; 10 | } 11 | } 12 | 13 | println!("{}", ans); 14 | } 15 | 16 | pub struct IO(R, std::io::BufWriter); 17 | 18 | impl IO { 19 | pub fn new(r: R, w: W) -> IO { 20 | IO(r, std::io::BufWriter::new(w)) 21 | } 22 | pub fn write>(&mut self, s: S) { 23 | use std::io::Write; 24 | self.1.write(s.as_bytes()).unwrap(); 25 | } 26 | pub fn read(&mut self) -> T { 27 | use std::io::Read; 28 | let buf = self 29 | .0 30 | .by_ref() 31 | .bytes() 32 | .map(|b| b.unwrap()) 33 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 34 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 35 | .collect::>(); 36 | unsafe { std::str::from_utf8_unchecked(&buf) } 37 | .parse() 38 | .ok() 39 | .expect("Parse error.") 40 | } 41 | pub fn vec(&mut self, n: usize) -> Vec { 42 | (0..n).map(|_| self.read()).collect() 43 | } 44 | pub fn chars(&mut self) -> Vec { 45 | self.read::().chars().collect() 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /atcoder/abc142_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: u64 = sc.read(); 5 | let b: u64 = sc.read(); 6 | let g = gcd(a, b); 7 | 8 | let mut primes = vec![]; 9 | let mut cur = g; 10 | for p in 2.. { 11 | if p * p > cur { 12 | break; 13 | } 14 | if cur % p == 0 { 15 | primes.push(p); 16 | while cur % p == 0 { 17 | cur /= p; 18 | } 19 | } 20 | } 21 | if cur > 1 { 22 | primes.push(cur); 23 | } 24 | 25 | println!("{}", primes.len() + 1); 26 | } 27 | 28 | fn gcd(a: u64, b: u64) -> u64 { 29 | if b == 0 { 30 | a 31 | } else { 32 | gcd(b, a % b) 33 | } 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n') 49 | .take_while(|&b| b != b' ' && b != b'\n') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/abc143_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let l: Vec = sc.vec(n); 6 | 7 | let mut two = vec![0; 10000]; 8 | for i in 0..n { 9 | for j in (i + 1)..n { 10 | let x = l[i] + l[j]; 11 | two[x] += 1; 12 | } 13 | } 14 | 15 | let mut ans = n * (n - 1) * (n - 2) / 6; 16 | for sum_length in 0..two.len() { 17 | let two_count = two[sum_length]; 18 | if two_count == 0 { 19 | continue; 20 | } 21 | for &single in l.iter() { 22 | if sum_length <= single { 23 | ans -= two_count; 24 | } 25 | } 26 | } 27 | println!("{}", ans); 28 | } 29 | 30 | pub struct Scanner { 31 | stdin: R, 32 | } 33 | 34 | impl Scanner { 35 | pub fn read(&mut self) -> T { 36 | use std::io::Read; 37 | let buf = self 38 | .stdin 39 | .by_ref() 40 | .bytes() 41 | .map(|b| b.unwrap()) 42 | .skip_while(|&b| b == b' ' || b == b'\n') 43 | .take_while(|&b| b != b' ' && b != b'\n') 44 | .collect::>(); 45 | unsafe { std::str::from_utf8_unchecked(&buf) } 46 | .parse() 47 | .ok() 48 | .expect("Parse error.") 49 | } 50 | pub fn vec(&mut self, n: usize) -> Vec { 51 | (0..n).map(|_| self.read()).collect() 52 | } 53 | pub fn chars(&mut self) -> Vec { 54 | self.read::().chars().collect() 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /atcoder/abc144_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let a: f64 = sc.read(); 5 | let b: f64 = sc.read(); 6 | let x: f64 = sc.read(); 7 | let s = x / a; 8 | // b*z/2==s 9 | let z = s * 2.0 / b; 10 | if z > a { 11 | let s = a * b - s; 12 | let z = s * 2.0 / a; 13 | // tan(t) = z/a 14 | let t = z.atan2(a); 15 | let d = t / std::f64::consts::PI * 180.0; 16 | // eprintln!("z={} t={}", z, t); 17 | println!("{}", d); 18 | } else { 19 | // tan(t) = b/z 20 | let t = b.atan2(z); 21 | let d = t / std::f64::consts::PI * 180.0; 22 | // eprintln!("z={} t={}", z, t); 23 | println!("{}", d); 24 | } 25 | } 26 | 27 | pub struct Scanner { 28 | stdin: R, 29 | } 30 | 31 | impl Scanner { 32 | pub fn read(&mut self) -> T { 33 | use std::io::Read; 34 | let buf = self 35 | .stdin 36 | .by_ref() 37 | .bytes() 38 | .map(|b| b.unwrap()) 39 | .skip_while(|&b| b == b' ' || b == b'\n') 40 | .take_while(|&b| b != b' ' && b != b'\n') 41 | .collect::>(); 42 | unsafe { std::str::from_utf8_unchecked(&buf) } 43 | .parse() 44 | .ok() 45 | .expect("Parse error.") 46 | } 47 | pub fn vec(&mut self, n: usize) -> Vec { 48 | (0..n).map(|_| self.read()).collect() 49 | } 50 | pub fn chars(&mut self) -> Vec { 51 | self.read::().chars().collect() 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /atcoder/abc127_d.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let n: usize = sc.read(); 8 | let m: usize = sc.read(); 9 | let mut cards = sc 10 | .vec::(n) 11 | .into_iter() 12 | .map(|x| (x, 1)) 13 | .collect::>(); 14 | for _ in 0..m { 15 | let b: usize = sc.read(); 16 | let c: u64 = sc.read(); 17 | cards.push((c, b)); 18 | } 19 | cards.sort(); 20 | 21 | let mut ans = 0; 22 | let mut count = n; 23 | for (num, c) in cards.into_iter().rev() { 24 | let add = cmp::min(c, count); 25 | ans += (add as u64) * num; 26 | count -= add; 27 | } 28 | println!("{}", ans); 29 | } 30 | 31 | pub struct Scanner { 32 | stdin: R, 33 | } 34 | 35 | impl Scanner { 36 | pub fn read(&mut self) -> T { 37 | use std::io::Read; 38 | let buf = self 39 | .stdin 40 | .by_ref() 41 | .bytes() 42 | .map(|b| b.unwrap()) 43 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 44 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 45 | .collect::>(); 46 | unsafe { std::str::from_utf8_unchecked(&buf) } 47 | .parse() 48 | .ok() 49 | .expect("Parse error.") 50 | } 51 | pub fn vec(&mut self, n: usize) -> Vec { 52 | (0..n).map(|_| self.read()).collect() 53 | } 54 | pub fn chars(&mut self) -> Vec { 55 | self.read::().chars().collect() 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /atcoder/abc110_a.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | use std::cmp; 53 | 54 | fn main() { 55 | input!(a: usize, b: usize, c: usize); 56 | 57 | let mut v = vec![a, b, c]; 58 | v.sort(); 59 | let ans = v[2] * 10 + v[1] + v[0]; 60 | println!("{}", ans); 61 | } 62 | -------------------------------------------------------------------------------- /atcoder/agc020_a.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | fn main() { 53 | input!(n: usize, a: usize, b: usize); 54 | let interval = b - a - 1; 55 | if interval % 2 == 1 { 56 | println!("Alice"); 57 | } else { 58 | println!("Borys"); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /atcoder/abc149_b.rs: -------------------------------------------------------------------------------- 1 | use std::cmp::min; 2 | 3 | fn main() { 4 | let (r, w) = (std::io::stdin(), std::io::stdout()); 5 | let mut sc = IO::new(r.lock(), w.lock()); 6 | 7 | let mut a: i64 = sc.read(); 8 | let mut b: i64 = sc.read(); 9 | let mut k: i64 = sc.read(); 10 | 11 | let eat = min(a, k); 12 | a -= eat; 13 | k -= eat; 14 | 15 | let eat = min(b, k); 16 | b -= eat; 17 | k -= eat; 18 | 19 | println!("{} {}", a, b); 20 | } 21 | 22 | pub struct IO(R, std::io::BufWriter); 23 | 24 | impl IO { 25 | pub fn new(r: R, w: W) -> IO { 26 | IO(r, std::io::BufWriter::new(w)) 27 | } 28 | pub fn write>(&mut self, s: S) { 29 | use std::io::Write; 30 | self.1.write(s.as_bytes()).unwrap(); 31 | } 32 | pub fn read(&mut self) -> T { 33 | use std::io::Read; 34 | let buf = self 35 | .0 36 | .by_ref() 37 | .bytes() 38 | .map(|b| b.unwrap()) 39 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 40 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 41 | .collect::>(); 42 | unsafe { std::str::from_utf8_unchecked(&buf) } 43 | .parse() 44 | .ok() 45 | .expect("Parse error.") 46 | } 47 | pub fn vec(&mut self, n: usize) -> Vec { 48 | (0..n).map(|_| self.read()).collect() 49 | } 50 | pub fn chars(&mut self) -> Vec { 51 | self.read::().chars().collect() 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /atcoder/code_festival_2018_quala_a.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | fn main() { 53 | input!(a: usize, b: usize, c: usize, s: usize); 54 | if a + b + c <= s && s <= a + b + c + 3 { 55 | println!("Yes"); 56 | } else { 57 | println!("No"); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /atcoder/abc134_c.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeMap; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let mut map = BTreeMap::new(); 9 | for &a in a.iter() { 10 | *map.entry(a).or_insert(0) += 1; 11 | } 12 | 13 | let mut keys = map.keys().map(|key| *key).collect::>(); 14 | keys.sort(); 15 | let n = keys.len(); 16 | let max = keys[n - 1]; 17 | let max_count = *map.get(&max).unwrap(); 18 | 19 | for a in a.into_iter() { 20 | if max_count > 1 { 21 | println!("{}", max); 22 | } else if a == max { 23 | println!("{}", keys[n - 2]); 24 | } else { 25 | println!("{}", max); 26 | } 27 | } 28 | } 29 | 30 | pub struct Scanner { 31 | stdin: R, 32 | } 33 | 34 | impl Scanner { 35 | pub fn read(&mut self) -> T { 36 | use std::io::Read; 37 | let buf = self 38 | .stdin 39 | .by_ref() 40 | .bytes() 41 | .map(|b| b.unwrap()) 42 | .skip_while(|&b| b == b' ' || b == b'\n') 43 | .take_while(|&b| b != b' ' && b != b'\n') 44 | .collect::>(); 45 | unsafe { std::str::from_utf8_unchecked(&buf) } 46 | .parse() 47 | .ok() 48 | .expect("Parse error.") 49 | } 50 | pub fn vec(&mut self, n: usize) -> Vec { 51 | (0..n).map(|_| self.read()).collect() 52 | } 53 | pub fn chars(&mut self) -> Vec { 54 | self.read::().chars().collect() 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /atcoder/agc031_b.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeMap; 2 | 3 | const MOD: u64 = 1e9 as u64 + 7; 4 | 5 | fn main() { 6 | let s = std::io::stdin(); 7 | let mut sc = Scanner { stdin: s.lock() }; 8 | 9 | let n = sc.read(); 10 | let mut a = vec![]; 11 | for _ in 0..n { 12 | let x: usize = sc.read(); 13 | if a.is_empty() || *a.iter().next_back().unwrap() != x { 14 | a.push(x); 15 | } 16 | } 17 | 18 | let n = a.len(); 19 | let mut dp = vec![0; n + 1]; 20 | let mut last = BTreeMap::new(); 21 | dp[0] = 1; 22 | for (i, a) in a.into_iter().enumerate() { 23 | dp[i + 1] += dp[i]; 24 | if let Some(&last) = last.get(&a) { 25 | dp[i + 1] += dp[last]; 26 | } 27 | last.insert(a, i + 1); 28 | dp[i + 1] %= MOD; 29 | } 30 | println!("{}", dp[n]); 31 | } 32 | 33 | pub struct Scanner { 34 | stdin: R, 35 | } 36 | 37 | impl Scanner { 38 | pub fn read(&mut self) -> T { 39 | use std::io::Read; 40 | let buf = self 41 | .stdin 42 | .by_ref() 43 | .bytes() 44 | .map(|b| b.unwrap()) 45 | .skip_while(|&b| b == b' ' || b == b'\n') 46 | .take_while(|&b| b != b' ' && b != b'\n') 47 | .collect::>(); 48 | unsafe { std::str::from_utf8_unchecked(&buf) } 49 | .parse() 50 | .ok() 51 | .expect("Parse error.") 52 | } 53 | pub fn vec(&mut self, n: usize) -> Vec { 54 | (0..n).map(|_| self.read()).collect() 55 | } 56 | pub fn chars(&mut self) -> Vec { 57 | self.read::().chars().collect() 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /atcoder/code_festival_2017_quala_d.rs: -------------------------------------------------------------------------------- 1 | const LENGTH: usize = 2000; 2 | const S: usize = 500; 3 | 4 | fn main() { 5 | let s = std::io::stdin(); 6 | let mut sc = Scanner { reader: s.lock() }; 7 | let h: usize = sc.read(); 8 | let w: usize = sc.read(); 9 | let d: usize = sc.read(); 10 | 11 | let mut big_table = vec![vec!['?'; LENGTH]; LENGTH]; 12 | let colors = vec![vec!['R', 'G'], vec!['B', 'Y']]; 13 | for i in 0..LENGTH { 14 | for j in 0..LENGTH { 15 | let ii = (i / d) % 2; 16 | let jj = (j / d) % 2; 17 | big_table[i][j] = colors[ii][jj]; 18 | } 19 | } 20 | 21 | for i in 0..h { 22 | for j in 0..w { 23 | let p = S + i + j; 24 | let q = S + i - j; 25 | print!("{}", big_table[p][q]); 26 | } 27 | println!(); 28 | } 29 | } 30 | 31 | pub struct Scanner { 32 | reader: R, 33 | } 34 | 35 | impl Scanner { 36 | pub fn read(&mut self) -> T { 37 | use std::io::Read; 38 | let buf = self 39 | .reader 40 | .by_ref() 41 | .bytes() 42 | .map(|b| b.unwrap()) 43 | .skip_while(|&b| b == b' ' || b == b'\n') 44 | .take_while(|&b| b != b' ' && b != b'\n') 45 | .collect::>(); 46 | unsafe { std::str::from_utf8_unchecked(&buf) } 47 | .parse() 48 | .ok() 49 | .expect("Parse error.") 50 | } 51 | pub fn read_vec(&mut self, n: usize) -> Vec { 52 | (0..n).map(|_| self.read()).collect() 53 | } 54 | pub fn chars(&mut self) -> Vec { 55 | self.read::().chars().collect() 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /atcoder/abc123_d.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let x: usize = sc.read(); 8 | let y: usize = sc.read(); 9 | let z: usize = sc.read(); 10 | let k: usize = sc.read(); 11 | let a: Vec = sc.vec(x); 12 | let b: Vec = sc.vec(y); 13 | let c: Vec = sc.vec(z); 14 | let mut ab = vec![]; 15 | for i in 0..x { 16 | for j in 0..y { 17 | ab.push(a[i] + b[j]); 18 | } 19 | } 20 | ab.sort(); 21 | ab.reverse(); 22 | 23 | let mut ans = vec![]; 24 | for &ab in (&ab[..cmp::min(k, x * y)]).iter() { 25 | for i in 0..z { 26 | ans.push(ab + c[i]); 27 | } 28 | } 29 | ans.sort(); 30 | ans.reverse(); 31 | for i in 0..k { 32 | println!("{}", ans[i]); 33 | } 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n') 49 | .take_while(|&b| b != b' ' && b != b'\n') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/tkppc4_1_f.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | const INF: u32 = std::u32::MAX; 4 | 5 | fn main() { 6 | let s = std::io::stdin(); 7 | let mut sc = Scanner { stdin: s.lock() }; 8 | let n: usize = sc.read(); 9 | let m: usize = sc.read(); 10 | let a: Vec> = (0..n) 11 | .map(|_| (0..m).map(|_| sc.read::()).collect()) 12 | .collect(); 13 | let weight: Vec> = (0..n) 14 | .map(|_| (0..m).map(|_| sc.read::()).collect()) 15 | .collect(); 16 | 17 | let mut dist = vec![INF; n + 1]; 18 | dist[0] = 0; 19 | for i in 0..n { 20 | let cur = dist[i]; 21 | for j in 0..m { 22 | let a = a[i][j]; 23 | let next = (cur + a - 1) / a * a + weight[i][j]; 24 | dist[i + 1] = cmp::min(dist[i + 1], next); 25 | } 26 | } 27 | println!("{}", dist[n]); 28 | } 29 | 30 | pub struct Scanner { 31 | stdin: R, 32 | } 33 | 34 | impl Scanner { 35 | pub fn read(&mut self) -> T { 36 | use std::io::Read; 37 | let buf = self 38 | .stdin 39 | .by_ref() 40 | .bytes() 41 | .map(|b| b.unwrap()) 42 | .skip_while(|&b| b == b' ' || b == b'\n') 43 | .take_while(|&b| b != b' ' && b != b'\n') 44 | .collect::>(); 45 | unsafe { std::str::from_utf8_unchecked(&buf) } 46 | .parse() 47 | .ok() 48 | .expect("Parse error.") 49 | } 50 | pub fn vec(&mut self, n: usize) -> Vec { 51 | (0..n).map(|_| self.read()).collect() 52 | } 53 | pub fn chars(&mut self) -> Vec { 54 | self.read::().chars().collect() 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /atcoder/abc137_d.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeSet; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let m: usize = sc.read(); 8 | 9 | let mut tasks = vec![]; 10 | for _ in 0..n { 11 | let days: usize = sc.read(); 12 | let value: u64 = sc.read(); 13 | tasks.push((value, days)); 14 | } 15 | tasks.sort(); 16 | tasks.reverse(); 17 | let mut remain = (0..(m + 1)).collect::>(); 18 | let mut ans = 0; 19 | for (value, days) in tasks.into_iter() { 20 | if m < days { 21 | continue; 22 | } 23 | let d = m - days; 24 | if let Some(&d) = remain.range(..(d + 1)).next_back() { 25 | remain.remove(&d); 26 | ans += value; 27 | } 28 | } 29 | println!("{}", ans); 30 | } 31 | 32 | pub struct Scanner { 33 | stdin: R, 34 | } 35 | 36 | impl Scanner { 37 | pub fn read(&mut self) -> T { 38 | use std::io::Read; 39 | let buf = self 40 | .stdin 41 | .by_ref() 42 | .bytes() 43 | .map(|b| b.unwrap()) 44 | .skip_while(|&b| b == b' ' || b == b'\n') 45 | .take_while(|&b| b != b' ' && b != b'\n') 46 | .collect::>(); 47 | unsafe { std::str::from_utf8_unchecked(&buf) } 48 | .parse() 49 | .ok() 50 | .expect("Parse error.") 51 | } 52 | pub fn vec(&mut self, n: usize) -> Vec { 53 | (0..n).map(|_| self.read()).collect() 54 | } 55 | pub fn chars(&mut self) -> Vec { 56 | self.read::().chars().collect() 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /atcoder/past201912_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | 5 | let n = sc.read(); 6 | let a: Vec = sc.vec(n); 7 | for i in 1..n { 8 | let prev = a[i - 1]; 9 | let cur = a[i]; 10 | if prev == cur { 11 | println!("stay"); 12 | } else if prev > cur { 13 | println!("down {}", prev - cur); 14 | } else { 15 | println!("up {}", cur - prev); 16 | } 17 | } 18 | } 19 | 20 | pub struct IO(R, std::io::BufWriter); 21 | 22 | impl IO { 23 | pub fn new(r: R, w: W) -> IO { 24 | IO(r, std::io::BufWriter::new(w)) 25 | } 26 | pub fn write>(&mut self, s: S) { 27 | use std::io::Write; 28 | self.1.write(s.as_bytes()).unwrap(); 29 | } 30 | pub fn read(&mut self) -> T { 31 | use std::io::Read; 32 | let buf = self 33 | .0 34 | .by_ref() 35 | .bytes() 36 | .map(|b| b.unwrap()) 37 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 38 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 39 | .collect::>(); 40 | unsafe { std::str::from_utf8_unchecked(&buf) } 41 | .parse() 42 | .ok() 43 | .expect("Parse error.") 44 | } 45 | pub fn vec(&mut self, n: usize) -> Vec { 46 | (0..n).map(|_| self.read()).collect() 47 | } 48 | pub fn chars(&mut self) -> Vec { 49 | self.read::().chars().collect() 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /atcoder/arc086_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let sc = std::io::stdin(); 3 | let mut sc = Scanner { reader: sc.lock() }; 4 | let n = sc.read(); 5 | let a: Vec = sc.read_vec(n); 6 | let abs_max = (0..n) 7 | .map(|i| (a[i].abs(), i)) 8 | .max() 9 | .map(|(_, i)| i) 10 | .unwrap(); 11 | let mut b: Vec = a.iter().map(|&ai| ai + a[abs_max]).collect(); 12 | 13 | let all_positive = b.iter().all(|&x| x >= 0); 14 | println!("{}", 2 * n - 1); 15 | for i in 0..n { 16 | println!("{} {}", abs_max + 1, i + 1); 17 | } 18 | if all_positive { 19 | for i in 1..n { 20 | println!("{} {}", i, i + 1); 21 | b[i] += b[i - 1]; 22 | } 23 | } else { 24 | for i in (1..n).rev() { 25 | println!("{} {}", i + 1, i); 26 | b[i - 1] += b[i]; 27 | } 28 | } 29 | } 30 | 31 | pub struct Scanner { 32 | reader: R, 33 | } 34 | 35 | impl Scanner { 36 | pub fn read(&mut self) -> T { 37 | use std::io::Read; 38 | let buf = self 39 | .reader 40 | .by_ref() 41 | .bytes() 42 | .map(|b| b.unwrap()) 43 | .skip_while(|&b| b == b' ' || b == b'\n') 44 | .take_while(|&b| b != b' ' && b != b'\n') 45 | .collect::>(); 46 | unsafe { std::str::from_utf8_unchecked(&buf) } 47 | .parse() 48 | .ok() 49 | .expect("Parse error.") 50 | } 51 | pub fn read_vec(&mut self, n: usize) -> Vec { 52 | (0..n).map(|_| self.read()).collect() 53 | } 54 | pub fn chars(&mut self) -> Vec { 55 | self.read::().chars().collect() 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /atcoder/jsc2019_final_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let m: usize = sc.read(); 6 | let a: Vec = sc.vec(n); 7 | let b: Vec = sc.vec(m); 8 | let max_a = *a.iter().max().unwrap(); 9 | let max_b = *b.iter().max().unwrap(); 10 | 11 | let mut pairs: Vec> = vec![None; max_a + max_b + 1]; 12 | for i in 0..n { 13 | for j in 0..m { 14 | let sum = a[i] + b[j]; 15 | match pairs[sum] { 16 | Some((x, y)) => { 17 | println!("{} {} {} {}", x, y, i, j); 18 | return; 19 | } 20 | None => { 21 | pairs[sum] = Some((i, j)); 22 | } 23 | } 24 | } 25 | } 26 | println!("-1"); 27 | } 28 | 29 | pub struct Scanner { 30 | stdin: R, 31 | } 32 | 33 | impl Scanner { 34 | pub fn read(&mut self) -> T { 35 | use std::io::Read; 36 | let buf = self 37 | .stdin 38 | .by_ref() 39 | .bytes() 40 | .map(|b| b.unwrap()) 41 | .skip_while(|&b| b == b' ' || b == b'\n') 42 | .take_while(|&b| b != b' ' && b != b'\n') 43 | .collect::>(); 44 | unsafe { std::str::from_utf8_unchecked(&buf) } 45 | .parse() 46 | .ok() 47 | .expect("Parse error.") 48 | } 49 | pub fn vec(&mut self, n: usize) -> Vec { 50 | (0..n).map(|_| self.read()).collect() 51 | } 52 | pub fn chars(&mut self) -> Vec { 53 | self.read::().chars().collect() 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /atcoder/abc139_f.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut e = vec![]; 6 | for _ in 0..n { 7 | let x: f64 = sc.read(); 8 | let y: f64 = sc.read(); 9 | e.push((x, y)); 10 | } 11 | e.sort_by(|&(x1, y1), &(x2, y2)| { 12 | let t1 = y1.atan2(x1); 13 | let t2 = y2.atan2(x2); 14 | t1.partial_cmp(&t2).unwrap() 15 | }); 16 | 17 | let mut ans = 0.0; 18 | for head in 0..n { 19 | let (mut sx, mut sy) = (0.0, 0.0); 20 | for i in 0..n { 21 | let (x, y) = e[(head + i) % n]; 22 | sx += x; 23 | sy += y; 24 | let s = sx * sx + sy * sy; 25 | if ans < s { 26 | ans = s; 27 | } 28 | } 29 | } 30 | 31 | println!("{}", ans.sqrt()); 32 | } 33 | 34 | pub struct Scanner { 35 | stdin: R, 36 | } 37 | 38 | impl Scanner { 39 | pub fn read(&mut self) -> T { 40 | use std::io::Read; 41 | let buf = self 42 | .stdin 43 | .by_ref() 44 | .bytes() 45 | .map(|b| b.unwrap()) 46 | .skip_while(|&b| b == b' ' || b == b'\n') 47 | .take_while(|&b| b != b' ' && b != b'\n') 48 | .collect::>(); 49 | unsafe { std::str::from_utf8_unchecked(&buf) } 50 | .parse() 51 | .ok() 52 | .expect("Parse error.") 53 | } 54 | pub fn vec(&mut self, n: usize) -> Vec { 55 | (0..n).map(|_| self.read()).collect() 56 | } 57 | pub fn chars(&mut self) -> Vec { 58 | self.read::().chars().collect() 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /atcoder/abc141_f.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let a: Vec = sc.vec(n); 6 | let xor_sum = a.iter().fold(0, |xor, &a| xor ^ a); 7 | let mut a = a.into_iter().map(|a| a & !xor_sum).collect::>(); 8 | 9 | let mut rank = 0; 10 | for pos in (0..62).rev() { 11 | if let Some(i) = (rank..n).find(|&i| a[i] & (1 << pos) != 0) { 12 | for j in 0..n { 13 | if i == j { 14 | continue; 15 | } 16 | if a[j] & (1 << pos) != 0 { 17 | a[j] ^= a[i]; 18 | } 19 | } 20 | a.swap(i, rank); 21 | rank += 1; 22 | } 23 | } 24 | 25 | let max = a.into_iter().fold(0, |xor, a| xor ^ a); 26 | println!("{}", max * 2 + xor_sum); 27 | } 28 | 29 | pub struct Scanner { 30 | stdin: R, 31 | } 32 | 33 | impl Scanner { 34 | pub fn read(&mut self) -> T { 35 | use std::io::Read; 36 | let buf = self 37 | .stdin 38 | .by_ref() 39 | .bytes() 40 | .map(|b| b.unwrap()) 41 | .skip_while(|&b| b == b' ' || b == b'\n') 42 | .take_while(|&b| b != b' ' && b != b'\n') 43 | .collect::>(); 44 | unsafe { std::str::from_utf8_unchecked(&buf) } 45 | .parse() 46 | .ok() 47 | .expect("Parse error.") 48 | } 49 | pub fn vec(&mut self, n: usize) -> Vec { 50 | (0..n).map(|_| self.read()).collect() 51 | } 52 | pub fn chars(&mut self) -> Vec { 53 | self.read::().chars().collect() 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /atcoder/abc126_f.rs: -------------------------------------------------------------------------------- 1 | use std::collections::VecDeque; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let m: usize = sc.read(); 7 | let k: usize = sc.read(); 8 | let max = (1 << m) - 1; 9 | if k > max { 10 | println!("-1"); 11 | return; 12 | } 13 | 14 | if m == 1 { 15 | if k == 0 { 16 | println!("0 0 1 1"); 17 | } else { 18 | println!("-1"); 19 | } 20 | return; 21 | } 22 | 23 | let mut ans = VecDeque::new(); 24 | ans.push_back(k); 25 | for i in 0..(max + 1) { 26 | if i == k { 27 | continue; 28 | } 29 | ans.push_front(i); 30 | ans.push_back(i); 31 | } 32 | ans.push_front(k); 33 | 34 | for a in ans.into_iter() { 35 | print!("{} ", a); 36 | } 37 | println!(); 38 | } 39 | 40 | pub struct Scanner { 41 | stdin: R, 42 | } 43 | 44 | impl Scanner { 45 | pub fn read(&mut self) -> T { 46 | use std::io::Read; 47 | let buf = self 48 | .stdin 49 | .by_ref() 50 | .bytes() 51 | .map(|b| b.unwrap()) 52 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 53 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 54 | .collect::>(); 55 | unsafe { std::str::from_utf8_unchecked(&buf) } 56 | .parse() 57 | .ok() 58 | .expect("Parse error.") 59 | } 60 | pub fn vec(&mut self, n: usize) -> Vec { 61 | (0..n).map(|_| self.read()).collect() 62 | } 63 | pub fn chars(&mut self) -> Vec { 64 | self.read::().chars().collect() 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /atcoder/agc001_c.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::cmp; 3 | 4 | fn main() { 5 | let (n, k) = { 6 | let v = read_values::(); 7 | (v[0], v[1]) 8 | }; 9 | 10 | let mut tree = vec![Vec::new(); n]; 11 | let mut edges = Vec::new(); 12 | for _ in 0..(n - 1) { 13 | let v = read_values::(); 14 | let from = v[0] - 1; 15 | let to = v[1] - 1; 16 | tree[from].push(to); 17 | tree[to].push(from); 18 | 19 | edges.push((from, to)); 20 | } 21 | 22 | if k % 2 == 1 { 23 | let mut max = 0; 24 | for edge in &edges { 25 | let (from, to) = *edge; 26 | let ans = dfs(&tree, from, to, 0, k / 2) + dfs(&tree, to, from, 0, k / 2); 27 | max = cmp::max(max, ans); 28 | } 29 | println!("{}", n - max); 30 | } else { 31 | let mut max = 0; 32 | for v in 0..n { 33 | let ans = dfs(&tree, v, n, 0, k / 2); 34 | max = cmp::max(ans, max); 35 | } 36 | println!("{}", n - max); 37 | } 38 | } 39 | 40 | fn dfs(tree: &Vec>, v: usize, p: usize, dist: usize, k: usize) -> usize { 41 | if dist > k { 42 | return 0; 43 | } 44 | let mut count = 1; 45 | for next in tree[v].iter() { 46 | if *next == p { 47 | continue; 48 | } 49 | count += dfs(tree, *next, v, dist + 1, k); 50 | } 51 | count 52 | } 53 | 54 | fn read_line() -> String { 55 | let stdin = io::stdin(); 56 | let mut buf = String::new(); 57 | stdin.read_line(&mut buf).unwrap(); 58 | buf 59 | } 60 | 61 | fn read_values() -> Vec where T: std::str::FromStr, T::Err: std::fmt::Debug { 62 | read_line() 63 | .split(' ') 64 | .map(|a| a.trim().parse().unwrap()) 65 | .collect() 66 | } -------------------------------------------------------------------------------- /atcoder/jsc2019_qual_b.rs: -------------------------------------------------------------------------------- 1 | const MOD: u64 = 1e9 as u64 + 7; 2 | fn main() { 3 | let s = std::io::stdin(); 4 | let mut sc = Scanner { stdin: s.lock() }; 5 | let n = sc.read(); 6 | let k: u64 = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let mut before = vec![0; n]; 9 | let mut after = vec![0; n]; 10 | for i in 0..n { 11 | for j in 0..n { 12 | if a[j] > a[i] && j < i { 13 | before[i] += 1; 14 | } 15 | if a[j] > a[i] && i < j { 16 | after[i] += 1; 17 | } 18 | } 19 | } 20 | 21 | let mut ans = 0; 22 | for i in 0..n { 23 | let b = (k * (k + 1) / 2) % MOD; 24 | let b = (before[i] * b) % MOD; 25 | 26 | let a = (k * (k - 1) / 2) % MOD; 27 | let a = (a * after[i]) % MOD; 28 | ans += a + b; 29 | ans %= MOD; 30 | } 31 | println!("{}", ans); 32 | } 33 | 34 | pub struct Scanner { 35 | stdin: R, 36 | } 37 | 38 | impl Scanner { 39 | pub fn read(&mut self) -> T { 40 | use std::io::Read; 41 | let buf = self 42 | .stdin 43 | .by_ref() 44 | .bytes() 45 | .map(|b| b.unwrap()) 46 | .skip_while(|&b| b == b' ' || b == b'\n') 47 | .take_while(|&b| b != b' ' && b != b'\n') 48 | .collect::>(); 49 | unsafe { std::str::from_utf8_unchecked(&buf) } 50 | .parse() 51 | .ok() 52 | .expect("Parse error.") 53 | } 54 | pub fn vec(&mut self, n: usize) -> Vec { 55 | (0..n).map(|_| self.read()).collect() 56 | } 57 | pub fn chars(&mut self) -> Vec { 58 | self.read::().chars().collect() 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /atcoder/mujin_pc_2017_b.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let a: Vec> = (0..n).map(|_| sc.chars()).collect::>(); 8 | 9 | if a.iter().all(|row| row.iter().all(|&c| c == '.')) { 10 | println!("-1"); 11 | return; 12 | } 13 | 14 | let mut ans = n * n; 15 | for row_id in 0..n { 16 | let white = a[row_id].iter().filter(|&&c| c == '.').count(); 17 | let white_columns = (0..n) 18 | .filter(|&column_id| (0..n).any(|row_id| a[row_id][column_id] == '.')) 19 | .count(); 20 | if a.iter().any(|row| row[row_id] == '#') { 21 | ans = cmp::min(ans, white + white_columns); 22 | } else { 23 | ans = cmp::min(ans, white + white_columns + 1); 24 | } 25 | } 26 | println!("{}", ans); 27 | } 28 | 29 | pub struct Scanner { 30 | stdin: R, 31 | } 32 | 33 | impl Scanner { 34 | pub fn read(&mut self) -> T { 35 | use std::io::Read; 36 | let buf = self 37 | .stdin 38 | .by_ref() 39 | .bytes() 40 | .map(|b| b.unwrap()) 41 | .skip_while(|&b| b == b' ' || b == b'\n') 42 | .take_while(|&b| b != b' ' && b != b'\n') 43 | .collect::>(); 44 | unsafe { std::str::from_utf8_unchecked(&buf) } 45 | .parse() 46 | .ok() 47 | .expect("Parse error.") 48 | } 49 | pub fn vec(&mut self, n: usize) -> Vec { 50 | (0..n).map(|_| self.read()).collect() 51 | } 52 | pub fn chars(&mut self) -> Vec { 53 | self.read::().chars().collect() 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /atcoder/abc135_d.rs: -------------------------------------------------------------------------------- 1 | const MOD: u64 = 1e9 as u64 + 7; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let s = sc.chars(); 7 | let n = s.len(); 8 | let mut dp = vec![0; 13]; 9 | dp[0] = 1; 10 | for i in 0..n { 11 | let mut next = vec![0; 13]; 12 | let c = s[i]; 13 | for r in 0..13 { 14 | if c == '?' { 15 | for c in 0..10 { 16 | let next_r = (r * 10 + c) % 13; 17 | next[next_r] += dp[r]; 18 | next[next_r] %= MOD; 19 | } 20 | } else { 21 | let c = c as usize - '0' as usize; 22 | let next_r = (r * 10 + c) % 13; 23 | next[next_r] += dp[r]; 24 | next[next_r] %= MOD; 25 | } 26 | } 27 | dp = next; 28 | } 29 | println!("{}", dp[5]); 30 | } 31 | 32 | pub struct Scanner { 33 | stdin: R, 34 | } 35 | 36 | impl Scanner { 37 | pub fn read(&mut self) -> T { 38 | use std::io::Read; 39 | let buf = self 40 | .stdin 41 | .by_ref() 42 | .bytes() 43 | .map(|b| b.unwrap()) 44 | .skip_while(|&b| b == b' ' || b == b'\n') 45 | .take_while(|&b| b != b' ' && b != b'\n') 46 | .collect::>(); 47 | unsafe { std::str::from_utf8_unchecked(&buf) } 48 | .parse() 49 | .ok() 50 | .expect("Parse error.") 51 | } 52 | pub fn vec(&mut self, n: usize) -> Vec { 53 | (0..n).map(|_| self.read()).collect() 54 | } 55 | pub fn chars(&mut self) -> Vec { 56 | self.read::().chars().collect() 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /atcoder/abc128_f.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n = sc.read(); 7 | let s: Vec = sc.vec(n); 8 | 9 | let mut ans = 0; 10 | for i in 1..n { 11 | let mut left_sum = 0; 12 | let mut right_sum = 0; 13 | let mut left_cur = 0; 14 | let mut right_cur = n - 1; 15 | while left_cur + i < n { 16 | left_cur += i; 17 | right_cur -= i; 18 | 19 | if (n - 1) % i == 0 && left_cur >= right_cur { 20 | break; 21 | } 22 | 23 | if right_cur <= i { 24 | break; 25 | } 26 | 27 | left_sum += s[left_cur]; 28 | right_sum += s[right_cur]; 29 | ans = cmp::max(ans, left_sum + right_sum); 30 | } 31 | } 32 | 33 | println!("{}", ans); 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 49 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/agc029_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { reader: s.lock() }; 4 | let n = sc.read(); 5 | let mut a: Vec = sc.read_vec(n); 6 | a.sort(); 7 | let mut used = vec![false; n]; 8 | let mut ans = 0; 9 | for i in (0..31).rev() { 10 | let pow = 1 << i; 11 | let mut head = 0; 12 | let mut tail = n - 1; 13 | while head < tail { 14 | while head < tail && used[head] { 15 | head += 1; 16 | } 17 | while head < tail && (used[tail] || pow < a[head] + a[tail]) { 18 | tail -= 1; 19 | } 20 | if a[head] + a[tail] == pow && head < tail { 21 | used[head] = true; 22 | used[tail] = true; 23 | ans += 1; 24 | } 25 | head += 1; 26 | } 27 | } 28 | 29 | println!("{}", ans); 30 | } 31 | 32 | pub struct Scanner { 33 | reader: R, 34 | } 35 | 36 | impl Scanner { 37 | pub fn read(&mut self) -> T { 38 | use std::io::Read; 39 | let buf = self 40 | .reader 41 | .by_ref() 42 | .bytes() 43 | .map(|b| b.unwrap()) 44 | .skip_while(|&b| b == b' ' || b == b'\n') 45 | .take_while(|&b| b != b' ' && b != b'\n') 46 | .collect::>(); 47 | unsafe { std::str::from_utf8_unchecked(&buf) } 48 | .parse() 49 | .ok() 50 | .expect("Parse error.") 51 | } 52 | pub fn read_vec(&mut self, n: usize) -> Vec { 53 | (0..n).map(|_| self.read()).collect() 54 | } 55 | pub fn chars(&mut self) -> Vec { 56 | self.read::().chars().collect() 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /atcoder/code_festival_2017_qualc_d.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let s = sc 8 | .chars() 9 | .into_iter() 10 | .map(|c| c as usize - 'a' as usize) 11 | .collect::>(); 12 | let inf = s.len(); 13 | let mut prefix_dp = vec![inf as u32; 1 << 26]; 14 | 15 | let mut cur: usize = 0; 16 | for s in s.into_iter() { 17 | cur ^= 1 << s; 18 | if cur.count_ones() <= 1 { 19 | prefix_dp[cur] = 1; 20 | } else { 21 | let mut min = prefix_dp[cur]; 22 | for i in 0..26 { 23 | let suffix = 1 << i; 24 | let prefix = cur ^ suffix; 25 | min = cmp::min(min, prefix_dp[prefix] + 1); 26 | } 27 | prefix_dp[cur] = min; 28 | } 29 | } 30 | 31 | println!("{}", prefix_dp[cur]); 32 | } 33 | 34 | pub struct Scanner { 35 | stdin: R, 36 | } 37 | 38 | impl Scanner { 39 | pub fn read(&mut self) -> T { 40 | use std::io::Read; 41 | let buf = self 42 | .stdin 43 | .by_ref() 44 | .bytes() 45 | .map(|b| b.unwrap()) 46 | .skip_while(|&b| b == b' ' || b == b'\n') 47 | .take_while(|&b| b != b' ' && b != b'\n') 48 | .collect::>(); 49 | unsafe { std::str::from_utf8_unchecked(&buf) } 50 | .parse() 51 | .ok() 52 | .expect("Parse error.") 53 | } 54 | pub fn vec(&mut self, n: usize) -> Vec { 55 | (0..n).map(|_| self.read()).collect() 56 | } 57 | pub fn chars(&mut self) -> Vec { 58 | self.read::().chars().collect() 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /atcoder/abc130_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let k: u64 = sc.read(); 6 | let a: Vec = sc.vec(n); 7 | let mut tail = 0; 8 | let mut sum = 0; 9 | let mut ans = 0; 10 | for head in 0..n { 11 | while tail <= head { 12 | sum += a[tail]; 13 | tail += 1; 14 | } 15 | while tail < n && sum + a[tail] < k { 16 | sum += a[tail]; 17 | tail += 1; 18 | } 19 | 20 | // [head, tail) 21 | // let z: u64 = a[head..tail].iter().sum(); 22 | // eprintln!("head={} tail={} {:?} {}", head, tail, &a[head..tail], z); 23 | ans += tail - head; 24 | if tail - head == 1 && a[head] >= k { 25 | ans -= 1; 26 | } 27 | 28 | sum -= a[head]; 29 | } 30 | println!("{}", n * (n + 1) / 2 - ans); 31 | } 32 | 33 | pub struct Scanner { 34 | stdin: R, 35 | } 36 | 37 | impl Scanner { 38 | pub fn read(&mut self) -> T { 39 | use std::io::Read; 40 | let buf = self 41 | .stdin 42 | .by_ref() 43 | .bytes() 44 | .map(|b| b.unwrap()) 45 | .skip_while(|&b| b == b' ' || b == b'\n') 46 | .take_while(|&b| b != b' ' && b != b'\n') 47 | .collect::>(); 48 | unsafe { std::str::from_utf8_unchecked(&buf) } 49 | .parse() 50 | .ok() 51 | .expect("Parse error.") 52 | } 53 | pub fn vec(&mut self, n: usize) -> Vec { 54 | (0..n).map(|_| self.read()).collect() 55 | } 56 | pub fn chars(&mut self) -> Vec { 57 | self.read::().chars().collect() 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /atcoder/tkppc4_1_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | 6 | let mut x: Vec = vec![]; 7 | x.push(sc.read()); 8 | for _ in 1..n { 9 | let tail = *x.iter().next_back().unwrap(); 10 | let a = sc.read::(); 11 | if a != tail { 12 | x.push(a); 13 | } 14 | } 15 | let n = x.len(); 16 | if n == 1 { 17 | println!("0"); 18 | return; 19 | } 20 | 21 | let mut increasing = x[1] > x[0]; 22 | let mut ans = vec![x[0], x[1]]; 23 | for i in 2..n { 24 | let tail = ans.len() - 1; 25 | if (increasing && x[i] > ans[tail]) || (!increasing && x[i] < ans[tail]) { 26 | ans[tail] = x[i]; 27 | } else { 28 | ans.push(x[i]); 29 | increasing = !increasing; 30 | } 31 | } 32 | 33 | println!("{}", ans.len()); 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n') 49 | .take_while(|&b| b != b' ' && b != b'\n') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/abc144_e.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let k: i64 = sc.read(); 8 | let mut a: Vec = sc.vec(n); 9 | let mut f: Vec = sc.vec(n); 10 | 11 | let a_sum = a.iter().sum::(); 12 | if a_sum <= k { 13 | println!("0"); 14 | return; 15 | } 16 | 17 | a.sort(); 18 | a.reverse(); 19 | f.sort(); 20 | 21 | let mut ok = 1e15 as i64; 22 | let mut ng = 0; 23 | while ok - ng > 1 { 24 | let max = (ok + ng) / 2; 25 | let mut pay = 0; 26 | for i in 0..n { 27 | let cost = max / f[i]; 28 | let head = a[i]; 29 | pay += cmp::max(head - cost, 0); 30 | } 31 | if pay <= k { 32 | ok = max; 33 | } else { 34 | ng = max; 35 | } 36 | } 37 | println!("{}", ok); 38 | } 39 | 40 | pub struct Scanner { 41 | stdin: R, 42 | } 43 | 44 | impl Scanner { 45 | pub fn read(&mut self) -> T { 46 | use std::io::Read; 47 | let buf = self 48 | .stdin 49 | .by_ref() 50 | .bytes() 51 | .map(|b| b.unwrap()) 52 | .skip_while(|&b| b == b' ' || b == b'\n') 53 | .take_while(|&b| b != b' ' && b != b'\n') 54 | .collect::>(); 55 | unsafe { std::str::from_utf8_unchecked(&buf) } 56 | .parse() 57 | .ok() 58 | .expect("Parse error.") 59 | } 60 | pub fn vec(&mut self, n: usize) -> Vec { 61 | (0..n).map(|_| self.read()).collect() 62 | } 63 | pub fn chars(&mut self) -> Vec { 64 | self.read::().chars().collect() 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /atcoder/agc027_b.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n = sc.read(); 7 | let x: u64 = sc.read(); 8 | let v: Vec = sc.vec(n); 9 | 10 | let mut sum = vec![0; n + 1]; 11 | for i in 0..n { 12 | sum[i + 1] = sum[i] + v[i]; 13 | } 14 | 15 | let mut min = 1e18 as u64; 16 | for k in 1..(n + 1) { 17 | let mut ans = x * ((n + k) as u64); 18 | for a in 0.. { 19 | if n < a * k { 20 | break; 21 | } 22 | let sum = if n >= (a + 1) * k { 23 | sum[n - a * k] - sum[n - (a + 1) * k] 24 | } else { 25 | sum[n - a * k] 26 | }; 27 | let m = if a == 0 { 5 } else { 2 * (a + 2) - 1 }; 28 | ans += sum * (m as u64); 29 | } 30 | min = cmp::min(min, ans); 31 | } 32 | println!("{}", min); 33 | } 34 | 35 | pub struct Scanner { 36 | stdin: R, 37 | } 38 | 39 | impl Scanner { 40 | pub fn read(&mut self) -> T { 41 | use std::io::Read; 42 | let buf = self 43 | .stdin 44 | .by_ref() 45 | .bytes() 46 | .map(|b| b.unwrap()) 47 | .skip_while(|&b| b == b' ' || b == b'\n') 48 | .take_while(|&b| b != b' ' && b != b'\n') 49 | .collect::>(); 50 | unsafe { std::str::from_utf8_unchecked(&buf) } 51 | .parse() 52 | .ok() 53 | .expect("Parse error.") 54 | } 55 | pub fn vec(&mut self, n: usize) -> Vec { 56 | (0..n).map(|_| self.read()).collect() 57 | } 58 | pub fn chars(&mut self) -> Vec { 59 | self.read::().chars().collect() 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /atcoder/arc066_b.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeMap; 2 | 3 | const MOD: u64 = 1e9 as u64 + 7; 4 | 5 | fn main() { 6 | let s = std::io::stdin(); 7 | let mut sc = Scanner { stdin: s.lock() }; 8 | let n: u64 = sc.read(); 9 | let mut map = BTreeMap::new(); 10 | println!("{}", solve(n, n, &mut map)); 11 | } 12 | 13 | fn solve(sum: u64, xor: u64, map: &mut BTreeMap<(u64, u64), u64>) -> u64 { 14 | if sum == 0 { 15 | return 1; 16 | } 17 | if let Some(&ans) = map.get(&(sum, xor)) { 18 | return ans; 19 | } 20 | let mut result = 0; 21 | 22 | // odd + odd 23 | if sum >= 2 { 24 | result += solve((sum - 2) >> 1, xor >> 1, map); 25 | } 26 | 27 | // even + even 28 | result += solve(sum >> 1, xor >> 1, map); 29 | 30 | // odd + even 31 | if sum > 0 { 32 | result += solve((sum - 1) >> 1, xor >> 1, map); 33 | } 34 | map.insert((sum, xor), result % MOD); 35 | result % MOD 36 | } 37 | 38 | pub struct Scanner { 39 | stdin: R, 40 | } 41 | 42 | impl Scanner { 43 | pub fn read(&mut self) -> T { 44 | use std::io::Read; 45 | let buf = self 46 | .stdin 47 | .by_ref() 48 | .bytes() 49 | .map(|b| b.unwrap()) 50 | .skip_while(|&b| b == b' ' || b == b'\n') 51 | .take_while(|&b| b != b' ' && b != b'\n') 52 | .collect::>(); 53 | unsafe { std::str::from_utf8_unchecked(&buf) } 54 | .parse() 55 | .ok() 56 | .expect("Parse error.") 57 | } 58 | pub fn vec(&mut self, n: usize) -> Vec { 59 | (0..n).map(|_| self.read()).collect() 60 | } 61 | pub fn chars(&mut self) -> Vec { 62 | self.read::().chars().collect() 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /atcoder/cf16_exhibition_final_g.rs: -------------------------------------------------------------------------------- 1 | const C: usize = 7; 2 | const BUF: usize = 600; 3 | 4 | fn main() { 5 | let s = std::io::stdin(); 6 | let mut sc = Scanner { stdin: s.lock() }; 7 | let mut k: usize = sc.read(); 8 | let mut precompute = [[0; C]; BUF]; 9 | 10 | for from in 0..BUF { 11 | for to in from..BUF { 12 | for next in 0..C { 13 | precompute[to][next] += if next == 0 { 14 | 1 15 | } else { 16 | precompute[from][next - 1] 17 | }; 18 | } 19 | } 20 | } 21 | 22 | let mut ans = String::new(); 23 | for i in (0..BUF).rev() { 24 | let count = k / precompute[i][C - 1]; 25 | k %= precompute[i][C - 1]; 26 | for _ in 0..count { 27 | ans.push('L'); 28 | } 29 | ans.push_str("AVITSEF"); 30 | } 31 | 32 | ans = ans.chars().rev().collect(); 33 | println!("{}", ans); 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n') 49 | .take_while(|&b| b != b' ' && b != b'\n') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/keyence2020_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let n: usize = sc.read(); 5 | let mut xl = (0..n) 6 | .map(|_| (sc.read::(), sc.read::())) 7 | .collect::>(); 8 | xl.sort(); 9 | let mut max = -(1 << 50); 10 | let mut count = 0; 11 | for (x, l) in xl.into_iter() { 12 | if max <= x - l { 13 | count += 1; 14 | max = x + l; 15 | } else if x + l <= max { 16 | max = x + l; 17 | } 18 | } 19 | println!("{}", count); 20 | } 21 | 22 | pub struct IO(R, std::io::BufWriter); 23 | 24 | impl IO { 25 | pub fn new(r: R, w: W) -> IO { 26 | IO(r, std::io::BufWriter::new(w)) 27 | } 28 | pub fn write>(&mut self, s: S) { 29 | use std::io::Write; 30 | self.1.write(s.as_bytes()).unwrap(); 31 | } 32 | pub fn read(&mut self) -> T { 33 | use std::io::Read; 34 | let buf = self 35 | .0 36 | .by_ref() 37 | .bytes() 38 | .map(|b| b.unwrap()) 39 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 40 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 41 | .collect::>(); 42 | unsafe { std::str::from_utf8_unchecked(&buf) } 43 | .parse() 44 | .ok() 45 | .expect("Parse error.") 46 | } 47 | pub fn vec(&mut self, n: usize) -> Vec { 48 | (0..n).map(|_| self.read()).collect() 49 | } 50 | pub fn chars(&mut self) -> Vec { 51 | self.read::().chars().collect() 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /atcoder/past201912_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let n: usize = sc.read(); 5 | let mut count = vec![0; n]; 6 | for _ in 0..n { 7 | let i = sc.read::() - 1; 8 | count[i] += 1; 9 | } 10 | 11 | if count.iter().all(|&c| c == 1) { 12 | println!("Correct"); 13 | } else { 14 | let (a, _) = count.iter().enumerate().find(|&(_, &c)| c == 2).unwrap(); 15 | let (b, _) = count.iter().enumerate().find(|&(_, &c)| c == 0).unwrap(); 16 | println!("{} {}", a + 1, b + 1); 17 | } 18 | } 19 | 20 | pub struct IO(R, std::io::BufWriter); 21 | 22 | impl IO { 23 | pub fn new(r: R, w: W) -> IO { 24 | IO(r, std::io::BufWriter::new(w)) 25 | } 26 | pub fn write>(&mut self, s: S) { 27 | use std::io::Write; 28 | self.1.write(s.as_bytes()).unwrap(); 29 | } 30 | pub fn read(&mut self) -> T { 31 | use std::io::Read; 32 | let buf = self 33 | .0 34 | .by_ref() 35 | .bytes() 36 | .map(|b| b.unwrap()) 37 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 38 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 39 | .collect::>(); 40 | unsafe { std::str::from_utf8_unchecked(&buf) } 41 | .parse() 42 | .ok() 43 | .expect("Parse error.") 44 | } 45 | pub fn vec(&mut self, n: usize) -> Vec { 46 | (0..n).map(|_| self.read()).collect() 47 | } 48 | pub fn chars(&mut self) -> Vec { 49 | self.read::().chars().collect() 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /atcoder/agc032_b.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | 5 | let n: usize = sc.read(); 6 | let mut pairs = vec![]; 7 | if n % 2 == 0 { 8 | for i in 0..(n / 2) { 9 | pairs.push(vec![i + 1, n - i]); 10 | } 11 | } else { 12 | for i in 0..(n / 2 + 1) { 13 | pairs.push(vec![i, n - i]); 14 | } 15 | } 16 | 17 | let m = pairs.len(); 18 | let mut edges = vec![]; 19 | for i in 0..m { 20 | for j in 0..i { 21 | for &from in pairs[i].iter() { 22 | for &to in pairs[j].iter() { 23 | if from == 0 || to == 0 { 24 | continue; 25 | } 26 | edges.push((from, to)); 27 | } 28 | } 29 | } 30 | } 31 | 32 | println!("{}", edges.len()); 33 | for (a, b) in edges.into_iter() { 34 | println!("{} {}", a, b); 35 | } 36 | } 37 | 38 | pub struct Scanner { 39 | stdin: R, 40 | } 41 | 42 | impl Scanner { 43 | pub fn read(&mut self) -> T { 44 | use std::io::Read; 45 | let buf = self 46 | .stdin 47 | .by_ref() 48 | .bytes() 49 | .map(|b| b.unwrap()) 50 | .skip_while(|&b| b == b' ' || b == b'\n') 51 | .take_while(|&b| b != b' ' && b != b'\n') 52 | .collect::>(); 53 | unsafe { std::str::from_utf8_unchecked(&buf) } 54 | .parse() 55 | .ok() 56 | .expect("Parse error.") 57 | } 58 | pub fn vec(&mut self, n: usize) -> Vec { 59 | (0..n).map(|_| self.read()).collect() 60 | } 61 | pub fn chars(&mut self) -> Vec { 62 | self.read::().chars().collect() 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /atcoder/agc027_a.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | fn main() { 53 | input!(n: usize, x: usize, a: [usize; n],); 54 | let mut a: Vec = a.clone(); 55 | a.sort(); 56 | let mut x = x; 57 | let mut ans = 0; 58 | for (i, &a) in a.iter().enumerate() { 59 | if i < n - 1 && a <= x { 60 | x -= a; 61 | ans += 1; 62 | } else if a == x { 63 | ans += 1; 64 | } 65 | } 66 | println!("{}", ans); 67 | } 68 | -------------------------------------------------------------------------------- /atcoder/ddcc2020_qual_a.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | 5 | let x: usize = sc.read(); 6 | let y: usize = sc.read(); 7 | let mut ans = 0; 8 | if x == 1 { 9 | ans += 300000; 10 | } 11 | if x == 2 { 12 | ans += 200000; 13 | } 14 | if x == 3 { 15 | ans += 100000; 16 | } 17 | if y == 1 { 18 | ans += 300000; 19 | } 20 | if y == 2 { 21 | ans += 200000; 22 | } 23 | if y == 3 { 24 | ans += 100000; 25 | } 26 | if x == 1 && y == 1 { 27 | ans += 400000; 28 | } 29 | println!("{}", ans); 30 | } 31 | 32 | pub struct IO(R, std::io::BufWriter); 33 | 34 | impl IO { 35 | pub fn new(r: R, w: W) -> IO { 36 | IO(r, std::io::BufWriter::new(w)) 37 | } 38 | pub fn write(&mut self, s: String) { 39 | use std::io::Write; 40 | self.1.write(s.as_bytes()).unwrap(); 41 | } 42 | pub fn read(&mut self) -> T { 43 | use std::io::Read; 44 | let buf = self 45 | .0 46 | .by_ref() 47 | .bytes() 48 | .map(|b| b.unwrap()) 49 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 50 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 51 | .collect::>(); 52 | unsafe { std::str::from_utf8_unchecked(&buf) } 53 | .parse() 54 | .ok() 55 | .expect("Parse error.") 56 | } 57 | pub fn vec(&mut self, n: usize) -> Vec { 58 | (0..n).map(|_| self.read()).collect() 59 | } 60 | pub fn chars(&mut self) -> Vec { 61 | self.read::().chars().collect() 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /atcoder/abc130_e.rs: -------------------------------------------------------------------------------- 1 | const MOD: usize = 1e9 as usize + 7; 2 | fn main() { 3 | let s = std::io::stdin(); 4 | let mut sc = Scanner { stdin: s.lock() }; 5 | let n: usize = sc.read(); 6 | let m: usize = sc.read(); 7 | 8 | let s: Vec = sc.vec(n); 9 | let t: Vec = sc.vec(m); 10 | 11 | let mut dp = vec![0; m + 1]; 12 | dp[0] = 1; 13 | for i in 0..n { 14 | let s = s[i]; 15 | let mut carry = 0; 16 | let mut next = dp.clone(); 17 | next[0] = 1; 18 | for j in 0..m { 19 | carry += dp[j]; 20 | carry %= MOD; 21 | if s == t[j] { 22 | next[j + 1] += carry; 23 | next[j + 1] %= MOD; 24 | } 25 | } 26 | // println!("dp={:?}", dp); 27 | dp = next; 28 | } 29 | // println!("dp={:?}", dp); 30 | 31 | let mut ans = 0; 32 | for a in dp.into_iter() { 33 | ans += a; 34 | ans %= MOD; 35 | } 36 | println!("{}", ans); 37 | } 38 | 39 | pub struct Scanner { 40 | stdin: R, 41 | } 42 | 43 | impl Scanner { 44 | pub fn read(&mut self) -> T { 45 | use std::io::Read; 46 | let buf = self 47 | .stdin 48 | .by_ref() 49 | .bytes() 50 | .map(|b| b.unwrap()) 51 | .skip_while(|&b| b == b' ' || b == b'\n') 52 | .take_while(|&b| b != b' ' && b != b'\n') 53 | .collect::>(); 54 | unsafe { std::str::from_utf8_unchecked(&buf) } 55 | .parse() 56 | .ok() 57 | .expect("Parse error.") 58 | } 59 | pub fn vec(&mut self, n: usize) -> Vec { 60 | (0..n).map(|_| self.read()).collect() 61 | } 62 | pub fn chars(&mut self) -> Vec { 63 | self.read::().chars().collect() 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /atcoder/abc142_e.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | const INF: u64 = std::u64::MAX / 2; 4 | 5 | fn main() { 6 | let s = std::io::stdin(); 7 | let mut sc = Scanner { stdin: s.lock() }; 8 | let n: usize = sc.read(); 9 | let m: usize = sc.read(); 10 | let mut keys = vec![]; 11 | for _ in 0..m { 12 | let a: u64 = sc.read(); 13 | let b: usize = sc.read(); 14 | let mut mask = 0; 15 | for _ in 0..b { 16 | let c = sc.read::() - 1; 17 | mask |= (1 << c); 18 | } 19 | keys.push((a, mask)); 20 | } 21 | 22 | let mut dp = vec![INF; 1 << n]; 23 | dp[0] = 0; 24 | for (price, key_mask) in keys.into_iter() { 25 | for mask in 0..(1 << n) { 26 | let next = mask | key_mask; 27 | dp[next] = cmp::min(dp[next], dp[mask] + price); 28 | } 29 | } 30 | 31 | let ans = dp[(1 << n) - 1]; 32 | if ans == INF { 33 | println!("-1"); 34 | } else { 35 | println!("{}", ans); 36 | } 37 | } 38 | 39 | pub struct Scanner { 40 | stdin: R, 41 | } 42 | 43 | impl Scanner { 44 | pub fn read(&mut self) -> T { 45 | use std::io::Read; 46 | let buf = self 47 | .stdin 48 | .by_ref() 49 | .bytes() 50 | .map(|b| b.unwrap()) 51 | .skip_while(|&b| b == b' ' || b == b'\n') 52 | .take_while(|&b| b != b' ' && b != b'\n') 53 | .collect::>(); 54 | unsafe { std::str::from_utf8_unchecked(&buf) } 55 | .parse() 56 | .ok() 57 | .expect("Parse error.") 58 | } 59 | pub fn vec(&mut self, n: usize) -> Vec { 60 | (0..n).map(|_| self.read()).collect() 61 | } 62 | pub fn chars(&mut self) -> Vec { 63 | self.read::().chars().collect() 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /atcoder/abc149_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | let x: usize = sc.read(); 5 | 6 | let mut is_prime = [true; 1000000]; 7 | is_prime[0] = false; 8 | is_prime[1] = false; 9 | for p in 2..is_prime.len() { 10 | if is_prime[p] { 11 | let mut cur = p * 2; 12 | while cur < is_prime.len() { 13 | is_prime[cur] = false; 14 | cur += p; 15 | } 16 | } 17 | } 18 | 19 | for i in x.. { 20 | if is_prime[i] { 21 | println!("{}", i); 22 | return; 23 | } 24 | } 25 | } 26 | 27 | pub struct IO(R, std::io::BufWriter); 28 | 29 | impl IO { 30 | pub fn new(r: R, w: W) -> IO { 31 | IO(r, std::io::BufWriter::new(w)) 32 | } 33 | pub fn write>(&mut self, s: S) { 34 | use std::io::Write; 35 | self.1.write(s.as_bytes()).unwrap(); 36 | } 37 | pub fn read(&mut self) -> T { 38 | use std::io::Read; 39 | let buf = self 40 | .0 41 | .by_ref() 42 | .bytes() 43 | .map(|b| b.unwrap()) 44 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 45 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 46 | .collect::>(); 47 | unsafe { std::str::from_utf8_unchecked(&buf) } 48 | .parse() 49 | .ok() 50 | .expect("Parse error.") 51 | } 52 | pub fn vec(&mut self, n: usize) -> Vec { 53 | (0..n).map(|_| self.read()).collect() 54 | } 55 | pub fn chars(&mut self) -> Vec { 56 | self.read::().chars().collect() 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /atcoder/jsc2019_qual_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut ans = vec![vec![0; n]; n]; 6 | let mut cur = 1; 7 | construct(&mut ans, 1, 0, n); 8 | for i in 0..n { 9 | for j in (i + 1)..n { 10 | print!("{} ", ans[i][j]); 11 | } 12 | println!(); 13 | } 14 | } 15 | 16 | fn construct(ans: &mut Vec>, depth: u64, from: usize, to: usize) { 17 | let length = to - from; 18 | let prefix = length / 2; 19 | let suffix = length - prefix; 20 | for i in 0..prefix { 21 | for j in 0..suffix { 22 | let left = from + i; 23 | let right = from + prefix + j; 24 | ans[left][right] = depth; 25 | ans[right][left] = depth; 26 | } 27 | } 28 | if prefix >= 2 { 29 | construct(ans, depth + 1, from, from + prefix); 30 | } 31 | if suffix >= 2 { 32 | construct(ans, depth + 1, from + prefix, to); 33 | } 34 | } 35 | 36 | pub struct Scanner { 37 | stdin: R, 38 | } 39 | 40 | impl Scanner { 41 | pub fn read(&mut self) -> T { 42 | use std::io::Read; 43 | let buf = self 44 | .stdin 45 | .by_ref() 46 | .bytes() 47 | .map(|b| b.unwrap()) 48 | .skip_while(|&b| b == b' ' || b == b'\n') 49 | .take_while(|&b| b != b' ' && b != b'\n') 50 | .collect::>(); 51 | unsafe { std::str::from_utf8_unchecked(&buf) } 52 | .parse() 53 | .ok() 54 | .expect("Parse error.") 55 | } 56 | pub fn vec(&mut self, n: usize) -> Vec { 57 | (0..n).map(|_| self.read()).collect() 58 | } 59 | pub fn chars(&mut self) -> Vec { 60 | self.read::().chars().collect() 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /atcoder/agc018_b.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let n: usize = sc.read(); 8 | let m: usize = sc.read(); 9 | let a: Vec> = (0..n) 10 | .map(|_| (0..m).map(|_| sc.read::() - 1).collect()) 11 | .collect(); 12 | 13 | let mut ans = n; 14 | let mut pos: Vec = vec![0; n]; 15 | let mut dead = vec![false; m]; 16 | for _ in 0..m { 17 | let mut count = vec![0; m]; 18 | for i in 0..n { 19 | count[a[i][pos[i]]] += 1; 20 | } 21 | let (max, max_i) = count 22 | .iter() 23 | .enumerate() 24 | .map(|(i, &c)| (c, i)) 25 | .max() 26 | .unwrap(); 27 | ans = cmp::min(ans, max); 28 | dead[max_i] = true; 29 | for i in 0..n { 30 | while pos[i] < m && dead[a[i][pos[i]]] { 31 | pos[i] += 1; 32 | } 33 | } 34 | } 35 | println!("{}", ans); 36 | } 37 | 38 | pub struct Scanner { 39 | stdin: R, 40 | } 41 | 42 | impl Scanner { 43 | pub fn read(&mut self) -> T { 44 | use std::io::Read; 45 | let buf = self 46 | .stdin 47 | .by_ref() 48 | .bytes() 49 | .map(|b| b.unwrap()) 50 | .skip_while(|&b| b == b' ' || b == b'\n') 51 | .take_while(|&b| b != b' ' && b != b'\n') 52 | .collect::>(); 53 | unsafe { std::str::from_utf8_unchecked(&buf) } 54 | .parse() 55 | .ok() 56 | .expect("Parse error.") 57 | } 58 | pub fn vec(&mut self, n: usize) -> Vec { 59 | (0..n).map(|_| self.read()).collect() 60 | } 61 | pub fn chars(&mut self) -> Vec { 62 | self.read::().chars().collect() 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /atcoder/abc134_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let a: Vec = sc.vec(n); 6 | let mut b = vec![0; n + 1]; 7 | for i in (0..n).rev() { 8 | let a = a[i]; 9 | let p = i + 1; 10 | let mut cur = p * 2; 11 | let mut sum = 0; 12 | while cur <= n { 13 | sum += b[cur]; 14 | cur += p; 15 | } 16 | if sum % 2 == a { 17 | b[p] = 0; 18 | } else if (sum + 1) % 2 == a { 19 | b[p] = 1; 20 | } else { 21 | println!("-1"); 22 | return; 23 | } 24 | } 25 | 26 | let mut ans = vec![]; 27 | for i in 1..(n + 1) { 28 | if b[i] == 1 { 29 | ans.push(i); 30 | } 31 | } 32 | println!("{}", ans.len()); 33 | for (i, ans) in ans.into_iter().enumerate() { 34 | if i > 0 { 35 | print!(" "); 36 | } 37 | print!("{}", ans); 38 | } 39 | println!(); 40 | } 41 | 42 | pub struct Scanner { 43 | stdin: R, 44 | } 45 | 46 | impl Scanner { 47 | pub fn read(&mut self) -> T { 48 | use std::io::Read; 49 | let buf = self 50 | .stdin 51 | .by_ref() 52 | .bytes() 53 | .map(|b| b.unwrap()) 54 | .skip_while(|&b| b == b' ' || b == b'\n') 55 | .take_while(|&b| b != b' ' && b != b'\n') 56 | .collect::>(); 57 | unsafe { std::str::from_utf8_unchecked(&buf) } 58 | .parse() 59 | .ok() 60 | .expect("Parse error.") 61 | } 62 | pub fn vec(&mut self, n: usize) -> Vec { 63 | (0..n).map(|_| self.read()).collect() 64 | } 65 | pub fn chars(&mut self) -> Vec { 66 | self.read::().chars().collect() 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /atcoder/keyence2020_c.rs: -------------------------------------------------------------------------------- 1 | const MAX: i64 = 1e9 as i64; 2 | fn main() { 3 | let (r, w) = (std::io::stdin(), std::io::stdout()); 4 | let mut sc = IO::new(r.lock(), w.lock()); 5 | 6 | let n: usize = sc.read(); 7 | let k: usize = sc.read(); 8 | let s: i64 = sc.read(); 9 | 10 | let mut ans = vec![]; 11 | for i in 0..n { 12 | if i < k { 13 | ans.push(s); 14 | } else if s == MAX { 15 | ans.push(s - 1); 16 | } else { 17 | ans.push(s + 1); 18 | } 19 | } 20 | 21 | for i in 0..n { 22 | if i > 0 { 23 | sc.write(" "); 24 | } 25 | sc.write(format!("{}", ans[i])); 26 | } 27 | sc.write("\n"); 28 | } 29 | 30 | pub struct IO(R, std::io::BufWriter); 31 | 32 | impl IO { 33 | pub fn new(r: R, w: W) -> IO { 34 | IO(r, std::io::BufWriter::new(w)) 35 | } 36 | pub fn write>(&mut self, s: S) { 37 | use std::io::Write; 38 | self.1.write(s.as_bytes()).unwrap(); 39 | } 40 | pub fn read(&mut self) -> T { 41 | use std::io::Read; 42 | let buf = self 43 | .0 44 | .by_ref() 45 | .bytes() 46 | .map(|b| b.unwrap()) 47 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 48 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 49 | .collect::>(); 50 | unsafe { std::str::from_utf8_unchecked(&buf) } 51 | .parse() 52 | .ok() 53 | .expect("Parse error.") 54 | } 55 | pub fn vec(&mut self, n: usize) -> Vec { 56 | (0..n).map(|_| self.read()).collect() 57 | } 58 | pub fn chars(&mut self) -> Vec { 59 | self.read::().chars().collect() 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /atcoder/abc143_f.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let mut count: Vec = vec![0; n]; 8 | for _ in 0..n { 9 | let a = sc.read::() - 1; 10 | count[a] += 1; 11 | } 12 | 13 | count.sort(); 14 | let mut ans = vec![0; n + 1]; 15 | let mut sum = count.iter().sum::(); 16 | let mut popped = 0; 17 | for height in (1..(n + 1)).rev() { 18 | while let Some(c) = count.pop() { 19 | if c >= height { 20 | sum -= c; 21 | popped += 1; 22 | } else { 23 | count.push(c); 24 | break; 25 | } 26 | } 27 | 28 | let columns = sum / height + popped; 29 | ans[columns] = cmp::max(ans[columns], height); 30 | } 31 | for k in (0..n).rev() { 32 | ans[k] = cmp::max(ans[k], ans[k + 1]); 33 | } 34 | 35 | for k in 1..(n + 1) { 36 | println!("{}", ans[k]); 37 | } 38 | } 39 | 40 | pub struct Scanner { 41 | stdin: R, 42 | } 43 | 44 | impl Scanner { 45 | pub fn read(&mut self) -> T { 46 | use std::io::Read; 47 | let buf = self 48 | .stdin 49 | .by_ref() 50 | .bytes() 51 | .map(|b| b.unwrap()) 52 | .skip_while(|&b| b == b' ' || b == b'\n') 53 | .take_while(|&b| b != b' ' && b != b'\n') 54 | .collect::>(); 55 | unsafe { std::str::from_utf8_unchecked(&buf) } 56 | .parse() 57 | .ok() 58 | .expect("Parse error.") 59 | } 60 | pub fn vec(&mut self, n: usize) -> Vec { 61 | (0..n).map(|_| self.read()).collect() 62 | } 63 | pub fn chars(&mut self) -> Vec { 64 | self.read::().chars().collect() 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /atcoder/agc005_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let mut a: Vec = sc.vec(n); 6 | a.sort(); 7 | let max = a[n - 1]; 8 | let mut count: Vec = vec![0; max + 1]; 9 | for a in a.into_iter() { 10 | count[a] += 1; 11 | } 12 | 13 | for d in 0..(max + 1) { 14 | if d * 2 < max { 15 | if count[d] > 0 { 16 | println!("Impossible"); 17 | return; 18 | } 19 | } else if d * 2 - 1 == max { 20 | if count[d] != 2 { 21 | println!("Impossible"); 22 | return; 23 | } 24 | } else if d * 2 == max { 25 | if count[d] != 1 { 26 | println!("Impossible"); 27 | return; 28 | } 29 | } else { 30 | if count[d] < 2 { 31 | println!("Impossible"); 32 | return; 33 | } 34 | } 35 | } 36 | println!("Possible"); 37 | } 38 | 39 | pub struct Scanner { 40 | stdin: R, 41 | } 42 | 43 | impl Scanner { 44 | pub fn read(&mut self) -> T { 45 | use std::io::Read; 46 | let buf = self 47 | .stdin 48 | .by_ref() 49 | .bytes() 50 | .map(|b| b.unwrap()) 51 | .skip_while(|&b| b == b' ' || b == b'\n') 52 | .take_while(|&b| b != b' ' && b != b'\n') 53 | .collect::>(); 54 | unsafe { std::str::from_utf8_unchecked(&buf) } 55 | .parse() 56 | .ok() 57 | .expect("Parse error.") 58 | } 59 | pub fn vec(&mut self, n: usize) -> Vec { 60 | (0..n).map(|_| self.read()).collect() 61 | } 62 | pub fn chars(&mut self) -> Vec { 63 | self.read::().chars().collect() 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /atcoder/arc069_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n = sc.read(); 5 | let mut a = sc 6 | .vec::(n) 7 | .into_iter() 8 | .enumerate() 9 | .map(|(i, a)| (-a, i)) 10 | .collect::>(); 11 | a.sort(); 12 | let mut ans = vec![0; n]; 13 | 14 | let mut garbage_count = 0; 15 | let mut garbage_num = -a[0].0; 16 | let mut stack = vec![]; 17 | let mut cur = a[0].1; 18 | for &(a, i) in a.iter() { 19 | let a = -a; 20 | if cur > i { 21 | ans[cur] += garbage_count * (garbage_num - a); 22 | garbage_num = a; 23 | while let Some(b) = stack.pop() { 24 | ans[cur] += b - a; 25 | garbage_count += 1; 26 | } 27 | cur = i; 28 | } 29 | stack.push(a); 30 | } 31 | ans[cur] += stack.into_iter().sum::(); 32 | ans[cur] += garbage_count * garbage_num; 33 | for c in ans.into_iter() { 34 | println!("{}", c); 35 | } 36 | } 37 | 38 | pub struct Scanner { 39 | stdin: R, 40 | } 41 | 42 | impl Scanner { 43 | pub fn read(&mut self) -> T { 44 | use std::io::Read; 45 | let buf = self 46 | .stdin 47 | .by_ref() 48 | .bytes() 49 | .map(|b| b.unwrap()) 50 | .skip_while(|&b| b == b' ' || b == b'\n') 51 | .take_while(|&b| b != b' ' && b != b'\n') 52 | .collect::>(); 53 | unsafe { std::str::from_utf8_unchecked(&buf) } 54 | .parse() 55 | .ok() 56 | .expect("Parse error.") 57 | } 58 | pub fn vec(&mut self, n: usize) -> Vec { 59 | (0..n).map(|_| self.read()).collect() 60 | } 61 | pub fn chars(&mut self) -> Vec { 62 | self.read::().chars().collect() 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /atcoder/arc092_d.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let mut sc = Scanner::new(); 3 | } 4 | 5 | struct Scanner { 6 | ptr: usize, 7 | length: usize, 8 | buf: Vec, 9 | small_cache: Vec, 10 | } 11 | 12 | impl Scanner { 13 | fn new() -> Scanner { 14 | Scanner { 15 | ptr: 0, 16 | length: 0, 17 | buf: vec![0; 1024], 18 | small_cache: vec![0; 1024], 19 | } 20 | } 21 | 22 | fn load(&mut self) { 23 | use std::io::Read; 24 | let mut s = std::io::stdin(); 25 | self.length = s.read(&mut self.buf).unwrap(); 26 | } 27 | 28 | fn byte(&mut self) -> u8 { 29 | if self.ptr >= self.length { 30 | self.ptr = 0; 31 | self.load(); 32 | if self.length == 0 { 33 | self.buf[0] = b'\n'; 34 | self.length = 1; 35 | } 36 | } 37 | 38 | self.ptr += 1; 39 | return self.buf[self.ptr - 1]; 40 | } 41 | 42 | fn is_space(b: u8) -> bool { 43 | b == b'\n' || b == b'\r' || b == b'\t' || b == b' ' 44 | } 45 | 46 | fn read(&mut self) -> T 47 | where 48 | T: std::str::FromStr, 49 | T::Err: std::fmt::Debug, 50 | { 51 | let mut b = self.byte(); 52 | while Scanner::is_space(b) { 53 | b = self.byte(); 54 | } 55 | 56 | for pos in 0..self.small_cache.len() { 57 | self.small_cache[pos] = b; 58 | b = self.byte(); 59 | if Scanner::is_space(b) { 60 | return String::from_utf8_lossy(&self.small_cache[0..(pos + 1)]) 61 | .parse() 62 | .unwrap(); 63 | } 64 | } 65 | 66 | let mut v = self.small_cache.clone(); 67 | while !Scanner::is_space(b) { 68 | v.push(b); 69 | b = self.byte(); 70 | } 71 | return String::from_utf8_lossy(&v).parse().unwrap(); 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /codejam/2019-round1b/draupnir.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let t: usize = sc.read(); 5 | let _: usize = sc.read(); 6 | for _ in 0..t { 7 | println!("200"); 8 | let day200: u64 = sc.read(); 9 | let ring4 = day200 / (1 << 50); 10 | let ring5 = (day200 - ring4 * (1 << 50)) / (1 << 40); 11 | let ring6 = (day200 - ring4 * (1 << 50) - ring5 * (1 << 40)) / (1 << 33); 12 | 13 | println!("50"); 14 | let day50: u64 = sc.read(); 15 | let day50 = day50 - ring4 * (1 << 12) - ring5 * (1 << 10) - ring6 * (1 << 8); 16 | let ring1 = day50 / (1 << 50); 17 | let ring2 = (day50 - ring1 * (1 << 50)) / (1 << 25); 18 | let ring3 = (day50 - ring1 * (1 << 50) - ring2 * (1 << 25)) / (1 << 16); 19 | 20 | println!( 21 | "{} {} {} {} {} {}", 22 | ring1, ring2, ring3, ring4, ring5, ring6 23 | ); 24 | 25 | let response: i64 = sc.read(); 26 | assert_eq!(response, 1); 27 | } 28 | } 29 | 30 | pub struct Scanner { 31 | stdin: R, 32 | } 33 | 34 | impl Scanner { 35 | pub fn read(&mut self) -> T { 36 | use std::io::Read; 37 | let buf = self 38 | .stdin 39 | .by_ref() 40 | .bytes() 41 | .map(|b| b.unwrap()) 42 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 43 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 44 | .collect::>(); 45 | unsafe { std::str::from_utf8_unchecked(&buf) } 46 | .parse() 47 | .ok() 48 | .expect("Parse error.") 49 | } 50 | pub fn vec(&mut self, n: usize) -> Vec { 51 | (0..n).map(|_| self.read()).collect() 52 | } 53 | pub fn chars(&mut self) -> Vec { 54 | self.read::().chars().collect() 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /atcoder/abc128_c.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = std::io::stdin(); 3 | let mut sc = Scanner { stdin: s.lock() }; 4 | let n: usize = sc.read(); 5 | let m: usize = sc.read(); 6 | let mut switches = vec![vec![]; m]; 7 | for i in 0..m { 8 | let k: usize = sc.read(); 9 | for _ in 0..k { 10 | let s: usize = sc.read::() - 1; 11 | switches[i].push(s); 12 | } 13 | } 14 | let p: Vec = sc.vec(m); 15 | 16 | let mut ans = 0; 17 | for mask in 0..(1 << n) { 18 | let mut ok = true; 19 | for (i, switch) in switches.iter().enumerate() { 20 | let mut count = 0; 21 | for &i in switch.iter() { 22 | if mask & (1 << i) != 0 { 23 | count += 1; 24 | } 25 | } 26 | 27 | if count % 2 != p[i] { 28 | ok = false; 29 | break; 30 | } 31 | } 32 | 33 | if ok { 34 | ans += 1; 35 | } 36 | } 37 | 38 | println!("{}", ans); 39 | } 40 | 41 | pub struct Scanner { 42 | stdin: R, 43 | } 44 | 45 | impl Scanner { 46 | pub fn read(&mut self) -> T { 47 | use std::io::Read; 48 | let buf = self 49 | .stdin 50 | .by_ref() 51 | .bytes() 52 | .map(|b| b.unwrap()) 53 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 54 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 55 | .collect::>(); 56 | unsafe { std::str::from_utf8_unchecked(&buf) } 57 | .parse() 58 | .ok() 59 | .expect("Parse error.") 60 | } 61 | pub fn vec(&mut self, n: usize) -> Vec { 62 | (0..n).map(|_| self.read()).collect() 63 | } 64 | pub fn chars(&mut self) -> Vec { 65 | self.read::().chars().collect() 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /atcoder/arc091_c.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n: usize = sc.read(); 7 | let a: usize = sc.read(); 8 | let b: usize = sc.read(); 9 | if a + b > n + 1 { 10 | println!("-1"); 11 | return; 12 | } 13 | 14 | let mut ans = (1..(n + 1)).collect::>(); 15 | for i in 0..((n + b - 1) / b) { 16 | ans[(i * b)..cmp::min(n, i * b + b)].reverse(); 17 | } 18 | 19 | let mut cur = (n + b - 1) / b; 20 | if cur > a { 21 | println!("-1"); 22 | return; 23 | } 24 | for i in (0..((n + b - 1) / b)).rev() { 25 | let from = (i * b); 26 | let to = cmp::min(n, i * b + b); 27 | let element = to - from; 28 | let reversing = cmp::min(element, a - cur + 1); 29 | ans[from..(reversing + from)].reverse(); 30 | cur += reversing - 1; 31 | if a == cur { 32 | break; 33 | } 34 | } 35 | 36 | for x in ans.into_iter() { 37 | print!("{} ", x); 38 | } 39 | println!(); 40 | } 41 | 42 | pub struct Scanner { 43 | stdin: R, 44 | } 45 | 46 | impl Scanner { 47 | pub fn read(&mut self) -> T { 48 | use std::io::Read; 49 | let buf = self 50 | .stdin 51 | .by_ref() 52 | .bytes() 53 | .map(|b| b.unwrap()) 54 | .skip_while(|&b| b == b' ' || b == b'\n') 55 | .take_while(|&b| b != b' ' && b != b'\n') 56 | .collect::>(); 57 | unsafe { std::str::from_utf8_unchecked(&buf) } 58 | .parse() 59 | .ok() 60 | .expect("Parse error.") 61 | } 62 | pub fn vec(&mut self, n: usize) -> Vec { 63 | (0..n).map(|_| self.read()).collect() 64 | } 65 | pub fn chars(&mut self) -> Vec { 66 | self.read::().chars().collect() 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /atcoder/arc079_b.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | fn main() { 53 | input!(k: usize); 54 | let n = 50; 55 | let mut b = vec![k / n; n]; 56 | for i in 0..(k % n) { 57 | b[i] += 1; 58 | } 59 | 60 | assert_eq!(b.iter().sum::(), k); 61 | let mut upper_a = vec![0; n]; 62 | for i in 0..n { 63 | upper_a[i] = (n + 1) * b[i] + (n - 1) - k; 64 | } 65 | println!("{}", n); 66 | for i in 0..n { 67 | if i > 0 { 68 | print!(" "); 69 | } 70 | print!("{}", upper_a[i]); 71 | } 72 | println!(); 73 | } 74 | -------------------------------------------------------------------------------- /atcoder/agc035_a.rs: -------------------------------------------------------------------------------- 1 | use std::collections::BTreeMap; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | 7 | let n: usize = sc.read(); 8 | let a: Vec = sc.vec(n); 9 | 10 | if solve(a) { 11 | println!("Yes"); 12 | } else { 13 | println!("No"); 14 | } 15 | } 16 | 17 | fn solve(a: Vec) -> bool { 18 | let n = a.len(); 19 | let mut count = BTreeMap::new(); 20 | for &a in a.iter() { 21 | *count.entry(a).or_insert(0) += 1; 22 | } 23 | let mut count = count.into_iter().collect::>(); 24 | count.sort(); 25 | if n % 3 != 0 { 26 | return count.len() == 1 && count[0].0 == 0; 27 | } 28 | if count.len() == 3 { 29 | let ((a, ac), (b, bc), (c, cc)) = (count[0], count[1], count[2]); 30 | ac == bc && ac == cc && a ^ b ^ c == 0 31 | } else if count.len() == 2 { 32 | let ((a, ac), (_, bc)) = (count[0], count[1]); 33 | a == 0 && ac * 2 == bc 34 | } else if count.len() == 1 { 35 | count[0].0 == 0 36 | } else { 37 | false 38 | } 39 | } 40 | 41 | pub struct Scanner { 42 | stdin: R, 43 | } 44 | 45 | impl Scanner { 46 | pub fn read(&mut self) -> T { 47 | use std::io::Read; 48 | let buf = self 49 | .stdin 50 | .by_ref() 51 | .bytes() 52 | .map(|b| b.unwrap()) 53 | .skip_while(|&b| b == b' ' || b == b'\n') 54 | .take_while(|&b| b != b' ' && b != b'\n') 55 | .collect::>(); 56 | unsafe { std::str::from_utf8_unchecked(&buf) } 57 | .parse() 58 | .ok() 59 | .expect("Parse error.") 60 | } 61 | pub fn vec(&mut self, n: usize) -> Vec { 62 | (0..n).map(|_| self.read()).collect() 63 | } 64 | pub fn chars(&mut self) -> Vec { 65 | self.read::().chars().collect() 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /aoj/2900.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | 3 | fn main() { 4 | let s = std::io::stdin(); 5 | let mut sc = Scanner { stdin: s.lock() }; 6 | let n = sc.read(); 7 | let a: Vec = sc.vec(n); 8 | let b = a.iter().map(|&a| -a).collect(); 9 | let a = solve(a); 10 | let b = solve(b); 11 | println!("{}", cmp::min(a, b)); 12 | } 13 | 14 | fn solve(mut a: Vec) -> usize { 15 | let n = a.len(); 16 | let mut ans = 0; 17 | for i in 0..(n - 1) { 18 | if i % 2 == 1 { 19 | a[i] *= -1; 20 | a[i + 1] *= -1; 21 | if i + 2 < n { 22 | a[i + 2] *= -1; 23 | } 24 | } 25 | if a[i] > a[i + 1] { 26 | if i + 2 < n && a[i] < a[i + 2] { 27 | a.swap(i + 1, i + 2); 28 | } else { 29 | a.swap(i, i + 1); 30 | } 31 | ans += 1; 32 | } 33 | if i % 2 == 1 { 34 | a[i] *= -1; 35 | a[i + 1] *= -1; 36 | if i + 2 < n { 37 | a[i + 2] *= -1; 38 | } 39 | } 40 | } 41 | ans 42 | } 43 | 44 | pub struct Scanner { 45 | stdin: R, 46 | } 47 | 48 | impl Scanner { 49 | pub fn read(&mut self) -> T { 50 | use std::io::Read; 51 | let buf = self 52 | .stdin 53 | .by_ref() 54 | .bytes() 55 | .map(|b| b.unwrap()) 56 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') 57 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') 58 | .collect::>(); 59 | unsafe { std::str::from_utf8_unchecked(&buf) } 60 | .parse() 61 | .ok() 62 | .expect("Parse error.") 63 | } 64 | pub fn vec(&mut self, n: usize) -> Vec { 65 | (0..n).map(|_| self.read()).collect() 66 | } 67 | pub fn chars(&mut self) -> Vec { 68 | self.read::().chars().collect() 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /atcoder/arc088_b.rs: -------------------------------------------------------------------------------- 1 | /// Thank you tanakh!!! 2 | /// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 3 | macro_rules! input { 4 | (source = $s:expr, $($r:tt)*) => { 5 | let mut iter = $s.split_whitespace(); 6 | input_inner!{iter, $($r)*} 7 | }; 8 | ($($r:tt)*) => { 9 | let mut s = { 10 | use std::io::Read; 11 | let mut s = String::new(); 12 | std::io::stdin().read_to_string(&mut s).unwrap(); 13 | s 14 | }; 15 | let mut iter = s.split_whitespace(); 16 | input_inner!{iter, $($r)*} 17 | }; 18 | } 19 | 20 | macro_rules! input_inner { 21 | ($iter:expr) => {}; 22 | ($iter:expr, ) => {}; 23 | 24 | ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { 25 | let $var = read_value!($iter, $t); 26 | input_inner!{$iter $($r)*} 27 | }; 28 | } 29 | 30 | macro_rules! read_value { 31 | ($iter:expr, ( $($t:tt),* )) => { 32 | ( $(read_value!($iter, $t)),* ) 33 | }; 34 | 35 | ($iter:expr, [ $t:tt ; $len:expr ]) => { 36 | (0..$len).map(|_| read_value!($iter, $t)).collect::>() 37 | }; 38 | 39 | ($iter:expr, chars) => { 40 | read_value!($iter, String).chars().collect::>() 41 | }; 42 | 43 | ($iter:expr, usize1) => { 44 | read_value!($iter, usize) - 1 45 | }; 46 | 47 | ($iter:expr, $t:ty) => { 48 | $iter.next().unwrap().parse::<$t>().expect("Parse error") 49 | }; 50 | } 51 | 52 | fn main() { 53 | input!(s: chars); 54 | 55 | if s.iter().all(|&c| c == s[0]) { 56 | println!("{}", s.len()); 57 | return; 58 | } 59 | 60 | let n = s.len(); 61 | let mut ok = (n + 1) / 2; 62 | let mut ng = n; 63 | while ng - ok > 1 { 64 | let k = (ng + ok) / 2; 65 | assert!(k < n); 66 | assert!(n - k < k); 67 | if s[(n - k)..k].iter().all(|&c| c == s[n - k]) { 68 | ok = k; 69 | } else { 70 | ng = k; 71 | } 72 | } 73 | println!("{}", ok); 74 | } 75 | -------------------------------------------------------------------------------- /atcoder/past201912_f.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let (r, w) = (std::io::stdin(), std::io::stdout()); 3 | let mut sc = IO::new(r.lock(), w.lock()); 4 | 5 | let mut s = sc.chars(); 6 | s.reverse(); 7 | let mut buf = String::new(); 8 | let mut words = vec![]; 9 | while let Some(c) = s.pop() { 10 | if c.is_uppercase() { 11 | if buf.is_empty() { 12 | buf.push(c); 13 | } else { 14 | buf.push(c); 15 | words.push(buf); 16 | buf = String::new(); 17 | } 18 | } else { 19 | buf.push(c); 20 | } 21 | } 22 | 23 | words.sort_by_key(|w| w.to_lowercase()); 24 | for word in words.into_iter() { 25 | sc.write(word); 26 | } 27 | sc.write("\n"); 28 | } 29 | 30 | pub struct IO(R, std::io::BufWriter); 31 | 32 | impl IO { 33 | pub fn new(r: R, w: W) -> IO { 34 | IO(r, std::io::BufWriter::new(w)) 35 | } 36 | pub fn write>(&mut self, s: S) { 37 | use std::io::Write; 38 | self.1.write(s.as_bytes()).unwrap(); 39 | } 40 | pub fn read(&mut self) -> T { 41 | use std::io::Read; 42 | let buf = self 43 | .0 44 | .by_ref() 45 | .bytes() 46 | .map(|b| b.unwrap()) 47 | .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t') 48 | .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t') 49 | .collect::>(); 50 | unsafe { std::str::from_utf8_unchecked(&buf) } 51 | .parse() 52 | .ok() 53 | .expect("Parse error.") 54 | } 55 | pub fn vec(&mut self, n: usize) -> Vec { 56 | (0..n).map(|_| self.read()).collect() 57 | } 58 | pub fn chars(&mut self) -> Vec { 59 | self.read::().chars().collect() 60 | } 61 | } 62 | --------------------------------------------------------------------------------