yenru0/CodeObject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

complete 9437.rs 12082.rs 12083.rs 12149.rs 17245.rs

Browse Source
This commit is contained in:
yenru0
2026-01-07 23:24:14 -08:00
parent 10119a8a3a
commit 73240ede3f
5 changed files with 386 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
storage/zeta/rs/completed/12082.rs Normal file
View File

@@ -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<String, usize> = 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::<Vec<(usize, usize)>>();
(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::<usize>().unwrap();
(0..t).for_each(|case| {
line.clear();
stdin().read_line(&mut line).unwrap();
let m = line.trim_ascii_end().parse::<usize>().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::<Vec<(String, String)>>();
println!(
"Case #{}: {}",
case + 1,
if check_split_bad_horse(pairs) {
"Yes"
} else {
"No"
}
);
});
}

119
storage/zeta/rs/completed/12083.rs Normal file
View File

@@ -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<String, usize> = 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::<Vec<(usize, usize)>>();
(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::<usize>().unwrap();
(0..t).for_each(|case| {
line.clear();
stdin().read_line(&mut line).unwrap();
let m = line.trim_ascii_end().parse::<usize>().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::<Vec<(String, String)>>();
println!(
"Case #{}: {}",
case + 1,
if check_split_bad_horse(pairs) {
"Yes"
} else {
"No"
}
);
});
}

71
storage/zeta/rs/completed/12149.rs Normal file
View File

@@ -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<char> = 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::<usize>().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);
});
}

43
storage/zeta/rs/completed/17245.rs Normal file
View File

@@ -0,0 +1,43 @@
use std::io::{read_to_string, stdin};
fn get_count_available_computers(field: &Vec<u64>, height: u64) -> u64 {
field
.iter()
.map(|&x| if x <= height { x } else { height })
.sum()
}
fn get_thresold(n: usize, field: &Vec<u64>) -> 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::<usize>().unwrap();
let mut field = (0..n * n)
.map(|_| iter.next().unwrap().parse::<u64>().unwrap())
.collect::<Vec<u64>>();
field.sort();
println!("{}", get_thresold(n, &field))
}

34
storage/zeta/rs/completed/9437.rs Normal file
View File

@@ -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::<usize>().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]);
}
}