From 73240ede3f277ce6d683ffe211df6551d0b5396b Mon Sep 17 00:00:00 2001 From: yenru0 Date: Wed, 7 Jan 2026 23:24:14 -0800 Subject: [PATCH] complete 9437.rs 12082.rs 12083.rs 12149.rs 17245.rs --- storage/zeta/rs/completed/12082.rs | 119 +++++++++++++++++++++++++++++ storage/zeta/rs/completed/12083.rs | 119 +++++++++++++++++++++++++++++ storage/zeta/rs/completed/12149.rs | 71 +++++++++++++++++ storage/zeta/rs/completed/17245.rs | 43 +++++++++++ storage/zeta/rs/completed/9437.rs | 34 +++++++++ 5 files changed, 386 insertions(+) create mode 100644 storage/zeta/rs/completed/12082.rs create mode 100644 storage/zeta/rs/completed/12083.rs create mode 100644 storage/zeta/rs/completed/12149.rs create mode 100644 storage/zeta/rs/completed/17245.rs create mode 100644 storage/zeta/rs/completed/9437.rs diff --git a/storage/zeta/rs/completed/12082.rs b/storage/zeta/rs/completed/12082.rs new file mode 100644 index 0000000..78341e2 --- /dev/null +++ b/storage/zeta/rs/completed/12082.rs @@ -0,0 +1,119 @@ +use std::{ + collections::{HashMap, HashSet}, + io::stdin, +}; + +fn convert_mapping_set(pairs: Vec<(String, String)>) -> (usize, Vec<(usize, usize)>) { + let mut i = 0; + + let mut mapping: HashMap = HashMap::new(); + let pairs = pairs + .into_iter() + .map(|(x, y)| { + let ix = if mapping.contains_key(&x) { + *mapping.get(&x).unwrap() + } else { + let before = i; + mapping.insert(x, i); + i += 1; + before + }; + let iy = if mapping.contains_key(&y) { + *mapping.get(&y).unwrap() + } else { + let before = i; + mapping.insert(y, i); + i += 1; + before + }; + + (ix, iy) + }) + .collect::>(); + (i, pairs) +} + +fn check_split_bad_horse(pairs: Vec<(String, String)>) -> bool { + let (n, pairs) = convert_mapping_set(pairs); + + let edges = { + let mut edges = vec![]; + + for _ in 0..n { + edges.push(vec![]); + } + + for (i, j) in pairs { + edges.get_mut(i).unwrap().push(j); + edges.get_mut(j).unwrap().push(i); + } + edges + }; + + let mut deque = vec![]; + let mut vis = vec![0; n]; + (0..n).rev().for_each(|i| deque.push((i, 0))); + let mut flag = true; + while !deque.is_empty() { + let (curr, before) = deque.pop().unwrap(); + + if before == 0 { + if vis[curr] == 0 { + // Separate Graph + vis[curr] = 1; + for &nxt in edges[curr].iter() { + deque.push((nxt, 1)); + } + } else { + continue; + } + } else { + let now = -before; + if vis[curr] == 0 { + vis[curr] = now; + for &nxt in edges[curr].iter() { + deque.push((nxt, now)); + } + } else { + if vis[curr] == now { + } else { + flag = false; + break; + } + } + } + } + + flag +} + +fn main() { + let mut line = String::new(); + stdin().read_line(&mut line).unwrap(); + let t = line.trim_ascii_end().parse::().unwrap(); + (0..t).for_each(|case| { + line.clear(); + stdin().read_line(&mut line).unwrap(); + let m = line.trim_ascii_end().parse::().unwrap(); + let pairs = (0..m) + .map(|_| { + line.clear(); + stdin().read_line(&mut line).unwrap(); + let mut iter = line.trim().split(' '); + ( + iter.next().unwrap().to_string(), + iter.next().unwrap().to_string(), + ) + }) + .collect::>(); + println!( + "Case #{}: {}", + case + 1, + if check_split_bad_horse(pairs) { + "Yes" + } else { + "No" + } + ); + }); +} diff --git a/storage/zeta/rs/completed/12083.rs b/storage/zeta/rs/completed/12083.rs new file mode 100644 index 0000000..78341e2 --- /dev/null +++ b/storage/zeta/rs/completed/12083.rs @@ -0,0 +1,119 @@ +use std::{ + collections::{HashMap, HashSet}, + io::stdin, +}; + +fn convert_mapping_set(pairs: Vec<(String, String)>) -> (usize, Vec<(usize, usize)>) { + let mut i = 0; + + let mut mapping: HashMap = HashMap::new(); + let pairs = pairs + .into_iter() + .map(|(x, y)| { + let ix = if mapping.contains_key(&x) { + *mapping.get(&x).unwrap() + } else { + let before = i; + mapping.insert(x, i); + i += 1; + before + }; + let iy = if mapping.contains_key(&y) { + *mapping.get(&y).unwrap() + } else { + let before = i; + mapping.insert(y, i); + i += 1; + before + }; + + (ix, iy) + }) + .collect::>(); + (i, pairs) +} + +fn check_split_bad_horse(pairs: Vec<(String, String)>) -> bool { + let (n, pairs) = convert_mapping_set(pairs); + + let edges = { + let mut edges = vec![]; + + for _ in 0..n { + edges.push(vec![]); + } + + for (i, j) in pairs { + edges.get_mut(i).unwrap().push(j); + edges.get_mut(j).unwrap().push(i); + } + edges + }; + + let mut deque = vec![]; + let mut vis = vec![0; n]; + (0..n).rev().for_each(|i| deque.push((i, 0))); + let mut flag = true; + while !deque.is_empty() { + let (curr, before) = deque.pop().unwrap(); + + if before == 0 { + if vis[curr] == 0 { + // Separate Graph + vis[curr] = 1; + for &nxt in edges[curr].iter() { + deque.push((nxt, 1)); + } + } else { + continue; + } + } else { + let now = -before; + if vis[curr] == 0 { + vis[curr] = now; + for &nxt in edges[curr].iter() { + deque.push((nxt, now)); + } + } else { + if vis[curr] == now { + } else { + flag = false; + break; + } + } + } + } + + flag +} + +fn main() { + let mut line = String::new(); + stdin().read_line(&mut line).unwrap(); + let t = line.trim_ascii_end().parse::().unwrap(); + (0..t).for_each(|case| { + line.clear(); + stdin().read_line(&mut line).unwrap(); + let m = line.trim_ascii_end().parse::().unwrap(); + let pairs = (0..m) + .map(|_| { + line.clear(); + stdin().read_line(&mut line).unwrap(); + let mut iter = line.trim().split(' '); + ( + iter.next().unwrap().to_string(), + iter.next().unwrap().to_string(), + ) + }) + .collect::>(); + println!( + "Case #{}: {}", + case + 1, + if check_split_bad_horse(pairs) { + "Yes" + } else { + "No" + } + ); + }); +} diff --git a/storage/zeta/rs/completed/12149.rs b/storage/zeta/rs/completed/12149.rs new file mode 100644 index 0000000..aac02b6 --- /dev/null +++ b/storage/zeta/rs/completed/12149.rs @@ -0,0 +1,71 @@ +use std::io::{read_to_string, stdin}; + +// maxima: 2 +// 1/4 * 2 + 1/4 * 1 + 1/4 +/* + + GO +*/ + +fn get_max_overlap(target: &String) -> usize { + let l = target.len(); + let chs: Vec = target.chars().collect(); + + for i in 1..l { + if chs[i..] == chs[..l - i] { + return l - i; + } + } + 0 +} + +fn expected_my_banana(keyboard: String, target: String, s: usize) -> f64 { + let k = keyboard.len(); + let l = target.len(); + let key_distribution = keyboard.chars().fold([0usize; 26], |mut acc, x| { + acc[x as usize - 'A' as usize] += 1; + accQ + }); + + let key_proba = key_distribution.map(|x| x as f64 / k as f64); + let proba_de_target = target + .chars() + .fold(1.0, |acc, x| acc * key_proba[x as usize - 'A' as usize]); + let overlap = get_max_overlap(&target); + + let maxima_banana: f64 = { + let mut flag = false; + for key in target.chars() { + if key_distribution[key as usize - 'A' as usize] == 0 { + flag = true; + break; + } + } + if flag { + return 0.0; + } else { + 1.0 + ((s - l) / (l - overlap)) as f64 + } + }; + + let expected_give = proba_de_target * (s - l + 1) as f64; + maxima_banana - expected_give +} + +fn main() { + let temp = read_to_string(stdin()).unwrap(); + let mut iter = temp.split_ascii_whitespace(); + + let n = iter.next().unwrap().parse::().unwrap(); + (0..n).for_each(|case| { + iter.next(); + iter.next(); + let s = iter.next().unwrap().parse().unwrap(); + + let keyboard = iter.next().unwrap().trim().to_string(); + let target = iter.next().unwrap().trim().to_string(); + + let res = expected_my_banana(keyboard, target, s); + println!("Case #{}: {:0.8}", case + 1, res); + }); +} diff --git a/storage/zeta/rs/completed/17245.rs b/storage/zeta/rs/completed/17245.rs new file mode 100644 index 0000000..a020dcc --- /dev/null +++ b/storage/zeta/rs/completed/17245.rs @@ -0,0 +1,43 @@ +use std::io::{read_to_string, stdin}; + +fn get_count_available_computers(field: &Vec, height: u64) -> u64 { + field + .iter() + .map(|&x| if x <= height { x } else { height }) + .sum() +} + +fn get_thresold(n: usize, field: &Vec) -> u64 { + let mut lo = 0; + let mut hi = 10_000_000; + let total = get_count_available_computers(field, hi); + while lo + 1 < hi { + let mid = (lo + hi) / 2; + let cnt = get_count_available_computers(field, mid); + if 2 * cnt >= total { + hi = mid; + } else { + lo = mid; + } + } + let cnt_lo = get_count_available_computers(field, lo); + if 2 * cnt_lo >= total { + lo + } else { + hi + } +} + +fn main() { + let temp = read_to_string(stdin()).unwrap(); + let mut iter = temp.split_ascii_whitespace(); + + let n = iter.next().unwrap().parse::().unwrap(); + + let mut field = (0..n * n) + .map(|_| iter.next().unwrap().parse::().unwrap()) + .collect::>(); + + field.sort(); + println!("{}", get_thresold(n, &field)) +} diff --git a/storage/zeta/rs/completed/9437.rs b/storage/zeta/rs/completed/9437.rs new file mode 100644 index 0000000..1f6105f --- /dev/null +++ b/storage/zeta/rs/completed/9437.rs @@ -0,0 +1,34 @@ +use std::io::stdin; + +fn main() { + let mut line = String::new(); + loop { + line.clear(); + stdin().read_line(&mut line).unwrap(); + let mut iter = line + .trim() + .split(' ') + .map(|x| x.trim().parse::().unwrap()); + + let n = iter.next().unwrap(); + if n == 0 { + break; + } + let p = iter.next().unwrap(); + + let mut res = vec![]; + if p % 2 == 0 { + res.push(p - 1); + res.push(n + 1 - p + 1); + res.push(n + 1 - p); + } else { + res.push(p + 1); + res.push(n - p); + res.push(n + 1 - p); + } + + res.sort(); + + println!("{} {} {}", res[0], res[1], res[2]); + } +}