結果
| 問題 | No.1946 ロッカーの問題 |
| ユーザー |
 manta1130
|
| 提出日時 | 2022-05-24 22:38:39 |
| 言語 | Rust (1.83.0 + proconio) |
| 結果 |
AC
|
| 実行時間 | 237 ms / 3,000 ms |
| コード長 | 14,183 bytes |
| コンパイル時間 | 13,906 ms |
| コンパイル使用メモリ | 381,964 KB |
| 実行使用メモリ | 6,944 KB |
| 最終ジャッジ日時 | 2024-09-20 14:33:19 |
| 合計ジャッジ時間 | 15,556 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| other | AC * 19 |
コンパイルメッセージ
warning: unused variable: `m`
--> src/main.rs:9:17
|
9 | n:usize,m:usize,
| ^
|
help: `m` is captured in macro and introduced a unused variable
--> src/main.rs:63:17
|
8 | / inputv! {
9 | | n:usize,m:usize,
10 | | }
| |_____- in this macro invocation
...
63 | let t = buf_split_result.parse().unwrap();
| ^^
= note: `#[warn(unused_variables)]` on by default
= note: this warning originates in the macro `input_internal` which comes from the expansion of the macro `inputv` (in Nightly builds, run with -Z macro-backtrace for more info)
ソースコード
#[allow(unused_imports)]use std::io::{stdout, BufWriter, Write};fn main() {let out = stdout();let mut out = BufWriter::new(out.lock());inputv! {n:usize,m:usize,}let k = input_vector::<usize>();let mut v = vec![false; n + 1];for i in k {v[i] = true;}let mut count = 0;for i in (1..v.len()).rev() {if v[i] {for k in i.get_divisor() {let k = k as usize;v[k] = !v[k];}count += 1;}}writeln!(out, "{}", n - count).unwrap();}//https://github.com/manta1130/competitive-template-rsuse input::*;use primenumber::*;pub mod input {use std::cell::RefCell;use std::io;pub const SPLIT_DELIMITER: char = ' ';pub use std::io::prelude::*;thread_local! {pub static INPUT_BUFFER:RefCell<std::collections::VecDeque<String>>=RefCell::new(std::collections::VecDeque::new());}#[macro_export]macro_rules! input_internal {($x:ident : $t:ty) => {INPUT_BUFFER.with(|p| {while p.borrow().len() == 0 {let temp_str = input_line_str();let mut split_result_iter = temp_str.split(SPLIT_DELIMITER).map(|q| q.to_string()).filter(|q| q.len() > 0).collect::<std::collections::VecDeque<_>>();p.borrow_mut().append(&mut split_result_iter)}});let mut buf_split_result = String::new();INPUT_BUFFER.with(|p| buf_split_result = p.borrow_mut().pop_front().unwrap());let $x: $t = buf_split_result.parse().unwrap();};(mut $x:ident : $t:ty) => {INPUT_BUFFER.with(|p| {while p.borrow().len() == 0 {let temp_str = input_line_str();let mut split_result_iter = temp_str.split(SPLIT_DELIMITER).map(|q| q.to_string()).filter(|q| q.len() > 0).collect::<std::collections::VecDeque<_>>();p.borrow_mut().append(&mut split_result_iter)}});let mut buf_split_result = String::new();INPUT_BUFFER.with(|p| buf_split_result = p.borrow_mut().pop_front().unwrap());let mut $x: $t = buf_split_result.parse().unwrap();};}pub fn input_buffer_is_empty() -> bool {let mut empty = false;INPUT_BUFFER.with(|p| {if p.borrow().len() == 0 {empty = true;}});empty}#[macro_export]macro_rules! inputv {($i:ident : $t:ty) => {input_internal!{$i : $t}};(mut $i:ident : $t:ty) => {input_internal!{mut $i : $t}};($i:ident : $t:ty $(,)*) => {input_internal!{$i : $t}};(mut $i:ident : $t:ty $(,)*) => {input_internal!{mut $i : $t}};(mut $i:ident : $t:ty,$($q:tt)*) => {input_internal!{mut $i : $t}inputv!{$($q)*}};($i:ident : $t:ty,$($q:tt)*) => {input_internal!{$i : $t}inputv!{$($q)*}};}pub fn input_all() {INPUT_BUFFER.with(|p| {if p.borrow().len() == 0 {let mut temp_str = String::new();std::io::stdin().read_to_string(&mut temp_str).unwrap();let mut split_result_iter = temp_str.split_whitespace().map(|q| q.to_string()).collect::<std::collections::VecDeque<_>>();p.borrow_mut().append(&mut split_result_iter)}});}pub fn input_line_str() -> String {let mut s = String::new();io::stdin().read_line(&mut s).unwrap();s.trim().to_string()}#[allow(clippy::match_wild_err_arm)]pub fn input_vector<T>() -> Vec<T>whereT: std::str::FromStr,{let mut v: Vec<T> = Vec::new();let s = input_line_str();if s.is_empty() {return v;}let split_result = s.split(SPLIT_DELIMITER);for z in split_result {let buf = match z.parse() {Ok(r) => r,Err(_) => panic!("Parse Error",),};v.push(buf);}v}#[allow(clippy::match_wild_err_arm)]pub fn input_vector_row<T>(n: usize) -> Vec<T>whereT: std::str::FromStr,{let mut v = Vec::with_capacity(n);for _ in 0..n {let buf = match input_line_str().parse() {Ok(r) => r,Err(_) => panic!("Parse Error",),};v.push(buf);}v}pub trait ToCharVec {fn to_charvec(&self) -> Vec<char>;}impl ToCharVec for String {fn to_charvec(&self) -> Vec<char> {self.to_string().chars().collect::<Vec<_>>()}}}pub mod primenumber {use std::iter::Iterator;type ValueType = u64;pub trait GetDivisor {fn get_divisor(&self) -> Divisor;}macro_rules! GetDivisor_macro{($($t:ty),*) => {$(impl GetDivisor for $t {fn get_divisor(&self) -> Divisor {Divisor::calc(*self as ValueType)}})*};}GetDivisor_macro!(u32, u64, u128, usize, i32, i64, i128, isize);pub trait GetPrimeFactorization {fn prime_factorization(&self) -> PrimeFactorization;}macro_rules! PrimeFactorization_macro{($($t:ty),*) => {$(impl GetPrimeFactorization for $t {fn prime_factorization(&self) -> PrimeFactorization {PrimeFactorization::calc(*self as ValueType)}})*};}PrimeFactorization_macro!(u32, u64, u128, usize, i32, i64, i128, isize);pub struct Divisor {n: ValueType,cur: ValueType,flag: bool,}impl Divisor {pub fn calc(n: ValueType) -> Divisor {Divisor {n,cur: 1,flag: false,}}}impl Iterator for Divisor {type Item = ValueType;fn next(&mut self) -> Option<Self::Item> {if self.cur * self.cur > self.n {None} else if self.flag {if self.cur * self.cur == self.n {return None;}self.flag = false;self.cur += 1;Some(self.n / (self.cur - 1))} else {while self.n % self.cur != 0 {self.cur += 1;if self.cur * self.cur > self.n {return None;}}self.flag = true;Some(self.cur)}}}pub struct PrimeFactorization<'a> {n: ValueType,cur: ValueType,p_list: Option<&'a [ValueType]>,idx: usize,}impl<'a> PrimeFactorization<'a> {pub fn calc(n: ValueType) -> PrimeFactorization<'a> {PrimeFactorization {n,cur: 1,p_list: None,idx: 0,}}pub fn calc_fast(n: ValueType, p_list: &'a [ValueType]) -> PrimeFactorization<'a> {PrimeFactorization {n,cur: 1,p_list: Some(p_list),idx: 0,}}}impl<'a> Iterator for PrimeFactorization<'a> {type Item = ValueType;fn next(&mut self) -> Option<Self::Item> {loop {if self.cur == 0 || self.cur > self.n {return None;}if self.p_list.is_some() {if self.idx >= self.p_list.unwrap().len() {return None;}self.cur = self.p_list.unwrap()[self.idx];self.idx += 1;} else {self.cur += 1;}if self.cur * self.cur > self.n {if self.n != 1 {self.cur = 0;return Some(self.n);}return None;}if self.n % self.cur == 0 {self.n /= self.cur;if self.p_list.is_some() {self.idx -= 1;}self.cur -= 1;return Some(self.cur + 1);}}}}pub fn get_primelist(u: ValueType) -> Vec<ValueType> {let mut v = vec![true; u as usize + 1];let mut r = vec![];for i in 2..=u as usize {if v[i] {r.push(i as ValueType);let mut j = i * i;while j <= u as usize {v[j] = false;j += i;}}}r}pub fn get_mobius(n: ValueType) -> Vec<isize> {let mut r = vec![0, 1];let p = get_primelist(n);for i in 2..=n {let mut f = PrimeFactorization::calc_fast(i as u64, &p).collect::<Vec<_>>();let count = f.len();f.dedup();if f.len() != count {r.push(0);} else {r.push(if f.len() % 2 == 0 { 1 } else { -1 });}}r}fn modpow_128bit(mut s: u128, mut n: u128, p: u128) -> u128 {if p == 0 {return 1;}let mut t = s;s = 1;while n > 0 {if n & 1 != 0 {s *= t;s %= p;}n >>= 1;t *= t;t %= p;}s}fn modpow_64bit(mut s: u64, mut n: u64, p: u64) -> u64 {if p == 0 {return 1;}let mut t = s;s = 1;while n > 0 {if n & 1 != 0 {s *= t;s %= p;}n >>= 1;t *= t;t %= p;}s}pub fn miller_rabin(n: u64) -> bool {if n == 2 {return true;}if n == 1 || n % 2 == 0 {return false;}let (mut s, mut t) = (0, n - 1);while t % 2 == 0 {s += 1;t >>= 1;}let arr = if n < 4_759_123_141 {vec![2, 7, 61]} else if n < 341_550_071_728_321 {vec![2, 3, 5, 7, 11, 13, 17]} else if n < 3_825_123_056_546_413_051 {vec![2, 3, 5, 7, 11, 13, 17, 19, 23]} else {vec![2, 325, 9_375, 28_178, 450_775, 9_780_504, 1_795_265_022]}.iter().filter(|&&q| q < n).cloned().collect::<Vec<_>>();let millor_rabin_inner = |a| {if modpow_128bit(a as u128, t as u128, n as u128) == 1 {return true;}for i in 0..s {if modpow_128bit(a as u128, 2_u128.pow(i) * t as u128, n as u128) as u64 == n - 1 {return true;}}false};let millor_rabin_inner_small = |a| {if modpow_64bit(a, t, n) == 1 {return true;}for i in 0..s {if modpow_64bit(a, 2_u64.pow(i) * t, n) == n - 1 {return true;}}false};if n < 1_000_000_000 {for a in arr {if !millor_rabin_inner_small(a) {return false;}}} else {for a in arr {if !millor_rabin_inner(a) {return false;}}}true}fn gcd_u64(a: u64, b: u64) -> u64where{if b + b == b {return a;}gcd_u64(b, a % b)}pub struct PollardRho {arr: Vec<u64>,}impl PollardRho {pub fn calc(n: u64) -> PollardRho {PollardRho { arr: vec![n] }}}impl Iterator for PollardRho {type Item = ValueType;#[allow(clippy::many_single_char_names)]fn next(&mut self) -> Option<Self::Item> {if self.arr.is_empty() || self.arr[0] == 0 {return None;}let n = self.arr.pop().unwrap();if n == 1 {return None;}if miller_rabin(n) {let r = n;return Some(r);}if n % 2 == 0 {self.arr.push(n / 2);return Some(2);}let f = |x, seed| ((x as u128 * x as u128 + seed as u128) % n as u128) as u64;let f_small = |x, seed| ((x * x + seed) % n);for s in 1.. {let (mut x, mut y, mut d) = (2, 2, 1);while d == 1 {if n <= 1_000_000_000 {x = f_small(x, s);y = f_small(f_small(y, s), s);} else {x = f(x, s);y = f(f(y, s), s);}d = gcd_u64(std::cmp::max(x, y) - std::cmp::min(x, y), n)}if d != n {self.arr.push(n / d);self.arr.push(d);return self.next();}}panic![]}}}