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

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<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"
+            }
+        );
+    });
+}

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<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"
+            }
+        );
+    });
+}

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<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);
+    });
+}

storage/zeta/rs/completed/17245.rs

@@ -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))
+}

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::<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]);
+    }
+}