complete 1024.rs 1063.rs 1108.rs 1111.rs 3086.rs 7695.rs 17256.rs 17371.rs 27634.rs 31846.rs

storage/zeta/rs/completed/1024.rs

@@ -0,0 +1,67 @@
+use std::io::stdin;
+
+fn can_lowerbound_accept(n: usize, l: usize) -> bool {
+    if l % 2 == 0 {
+        let d = n / l;
+        if d >= l / 2 { true } else { false }
+    } else {
+        let d = n / l;
+        if d >= l / 2 { true } else { false }
+    }
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let mut iter = line
+        .trim_ascii_end()
+        .split(' ')
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let l = iter.next().unwrap();
+
+    let mut candidate = vec![];
+
+    for i in l..=100 {
+        if 2 * n % i == 0 {
+            let d = 2 * n / i;
+            if d % 2 != 0 { // even
+                if i % 2 != 0 {
+                    continue;
+                } else {
+                    let mid = d / 2;
+                    if mid < i / 2 - 1 {
+                        break;
+                    }
+                    let lo = mid + 1 - i / 2;
+                    for j in lo..lo + i {
+                        candidate.push(j);
+                    }
+                    break;
+                }
+            } else { // odd
+                if i % 2 == 0 {
+                    continue;
+                } else {
+                    let mid = d / 2;
+                    if mid < i / 2 {
+                        break;
+                    }
+                    let lo = mid - i / 2;
+                    for j in lo..lo + i {
+                        candidate.push(j);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    if candidate.len() == 0 {
+        println!("-1");
+    } else {
+        for i in candidate {
+            print!("{} ", i);
+        }
+    }
+}

storage/zeta/rs/completed/1063.rs

@@ -0,0 +1,100 @@
+use std::io::{read_to_string, stdin};
+
+enum Movement {
+    R,
+    L,
+    B,
+    T,
+    RT,
+    LT,
+    RB,
+    LB,
+}
+
+impl Movement {
+    fn from_str(s: &str) -> Self {
+        match s {
+            "R" => Self::R,
+            "L" => Self::L,
+            "B" => Self::B,
+            "T" => Self::T,
+            "RT" => Self::RT,
+            "LT" => Self::LT,
+            "RB" => Self::RB,
+            "LB" => Self::LB,
+            _ => panic!("Invalid movement"),
+        }
+    }
+
+    fn to_delta(&self) -> (i8, i8) {
+        match self {
+            Self::R => (1, 0),
+            Self::L => (-1, 0),
+            Self::B => (0, -1),
+            Self::T => (0, 1),
+            Self::RT => (1, 1),
+            Self::LT => (-1, 1),
+            Self::RB => (1, -1),
+            Self::LB => (-1, -1),
+        }
+    }
+}
+
+fn to_pos(s: &str) -> (u8, u8) {
+    (s.as_bytes()[0] - b'A', s.as_bytes()[1] - b'1')
+}
+
+fn to_code(pos: (u8, u8)) -> String {
+    let col = (pos.0 + b'A') as char;
+    let row = (pos.1 + b'1') as char;
+    format!("{}{}", col, row)
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp.split_ascii_whitespace();
+
+    let str_king = iter.next().unwrap();
+    let mut pos_king = to_pos(str_king);
+
+    let str_stone = iter.next().unwrap();
+    let mut pos_stone = to_pos(str_stone);
+
+    let n = iter.next().unwrap().parse::<usize>().unwrap();
+
+    let movements = iter
+        .take(n)
+        .map(Movement::from_str)
+        .collect::<Vec<Movement>>();
+
+    for mv in movements {
+        let (dx, dy) = mv.to_delta();
+        let new_pos_king = (pos_king.0 as i8 + dx, pos_king.1 as i8 + dy);
+        if new_pos_king.0 < 0 || new_pos_king.0 >= 8 || new_pos_king.1 < 0 || new_pos_king.1 >= 8 {
+            continue;
+        }
+
+        let new_pos_king = (new_pos_king.0 as u8, new_pos_king.1 as u8);
+
+        if new_pos_king == pos_stone {
+            let new_pos_stone = (pos_stone.0 as i8 + dx, pos_stone.1 as i8 + dy);
+
+            if new_pos_stone.0 < 0
+                || new_pos_stone.0 >= 8
+                || new_pos_stone.1 < 0
+                || new_pos_stone.1 >= 8
+            {
+                continue;
+            }
+            let new_pos_stone = (new_pos_stone.0 as u8, new_pos_stone.1 as u8);
+
+            pos_stone = new_pos_stone;
+            pos_king = new_pos_king;
+        } else {
+            pos_king = new_pos_king;
+        }
+    }
+
+    println!("{}", to_code(pos_king));
+    println!("{}", to_code(pos_stone));
+}

storage/zeta/rs/completed/1108.rs

@@ -0,0 +1,105 @@
+use std::{collections::HashMap, io::stdin};
+
+fn score(graph: &Vec<Vec<usize>>, guess: usize) -> usize {
+    let n = graph.len();
+
+    let mut reach = vec![vec![false; n]; n];
+    for i in 0..n {
+        for j in 0..n {
+            if graph[i][j] == 1 {
+                reach[i][j] = true;
+            }
+        }
+    }
+
+    for k in 0..n {
+        for i in 0..n {
+            for j in 0..n {
+                if reach[i][k] && reach[k][j] {
+                    reach[i][j] = true;
+                }
+            }
+        }
+    }
+
+    let mut memo = vec![usize::MAX; n];
+
+    fn get_score(
+        curr: usize,
+        n: usize,
+        graph: &Vec<Vec<usize>>,
+        reachable: &Vec<Vec<bool>>,
+        memo: &mut Vec<usize>,
+    ) -> usize {
+        if memo[curr] != usize::MAX {
+            return memo[curr];
+        }
+
+        let mut total = 1;
+
+        for next in 0..n {
+            if graph[curr][next] == 1 && !reachable[next][curr] {
+                total += get_score(next, n, graph, reachable, memo);
+            }
+        }
+
+        memo[curr] = total;
+        total
+    }
+
+    get_score(guess, n, graph, &reach, &mut memo)
+}
+fn main() {
+    let mut line = String::new();
+
+    stdin().read_line(&mut line).unwrap();
+
+    let n = line.trim().parse::<usize>().unwrap();
+
+    let mut name_map = HashMap::new();
+
+    let mut idx: usize = 0;
+    let edges_info = (0..n)
+        .map(|_| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            let mut iter = line.trim().split(' ');
+
+            let start = iter.next().unwrap().trim().to_string();
+            if !name_map.contains_key(&start) {
+                name_map.insert(start.clone(), idx);
+                idx += 1;
+            }
+            let cnt = iter.next().unwrap().parse::<usize>().unwrap();
+            let dests = (0..cnt)
+                .map(|_| {
+                    let t = iter.next().unwrap().trim().to_string();
+                    if !name_map.contains_key(&t) {
+                        name_map.insert(t.clone(), idx);
+                        idx += 1;
+                    }
+                    t
+                })
+                .collect::<Vec<String>>();
+
+            (start, dests)
+        })
+        .collect::<Vec<(String, Vec<String>)>>();
+
+    let mut graph = vec![vec![0; idx]; idx];
+
+    for (start, dests) in edges_info {
+        let start_idx = name_map[&start];
+        for dest in dests {
+            let dest_idx = name_map[&dest];
+            graph[start_idx][dest_idx] = 1;
+        }
+    }
+
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let guess = line.trim().to_string();
+    let guess_idx = name_map[&guess];
+
+    println!("{}", score(&graph, guess_idx));
+}

storage/zeta/rs/completed/1111.rs

@@ -0,0 +1,73 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n = line.trim().parse::<usize>().unwrap();
+
+    line.clear();
+
+    stdin().read_line(&mut line).unwrap();
+    let arr = line
+        .trim()
+        .split(' ')
+        .map(|x| x.parse::<i32>().unwrap())
+        .collect::<Vec<i32>>();
+
+    if n <= 1 {
+        println!("A");
+    } else if n == 2 {
+        if arr[0] == arr[1] {
+            println!("{}", arr[0]);
+        } else {
+            println!("A");
+        }
+    } else {
+        if arr[0] == arr[1] {
+            let same_flag = arr.iter().all(|&x| x == arr[0]);
+
+            if same_flag {
+                println!("{}", arr[0]);
+            } else {
+                println!("B");
+            }
+        } else {
+            if arr[1] == arr[2] {
+                for i in 2..n - 1 {
+                    if arr[i + 1] == arr[i] {
+                        continue;
+                    } else {
+                        println!("B");
+                        return;
+                    }
+                }
+                println!("{}", arr[n - 1]);
+            } else {
+                let d_a = arr[2] - arr[1];
+                let d_b = arr[1] - arr[0];
+
+                if d_a % d_b == 0 {
+                    let a = d_a / d_b;
+                    let b = arr[1] - a * arr[0];
+                    let mut flag = true;
+                    for i in 1..n - 1 {
+                        if arr[i + 1] == arr[i] * a + b {
+                            continue;
+                        } else {
+                            flag = false;
+                            break;
+                        }
+                    }
+
+                    if flag {
+                        println!("{}", arr[n - 1] * a + b);
+                    } else {
+                        println!("B");
+                    }
+                } else {
+                    println!("B");
+                }
+            }
+        }
+    }
+}

storage/zeta/rs/completed/17256.rs

@@ -0,0 +1,25 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+
+    let mut iter = line.trim().split(' ').map(|s| s.parse::<usize>().unwrap());
+    let a = (
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+    );
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let mut iter = line.trim().split(' ').map(|s| s.parse::<usize>().unwrap());
+    let c = (
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+    );
+
+    let b = (c.0 - a.2, c.1 / a.1, c.2 - a.0);
+
+    println!("{} {} {}", b.0, b.1, b.2);
+}

storage/zeta/rs/completed/17371.rs

@@ -0,0 +1,84 @@
+use std::io::stdin;
+
+fn optimized_pos(poses: &Vec<(f64, f64)>) -> (f64, f64) {
+    let n = poses.len();
+    if n == 0 {
+        return (0.0, 0.0);
+    }
+    if n == 1 {
+        return poses[0];
+    }
+
+    let mut sorted_poses = poses.clone();
+    sorted_poses.sort_by(|a, b| {
+        a.0.partial_cmp(&b.0)
+            .unwrap_or(std::cmp::Ordering::Equal)
+            .then(a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal))
+    });
+
+    fn cross_product(o: (f64, f64), a: (f64, f64), b: (f64, f64)) -> f64 {
+        (a.0 - o.0) * (b.1 - o.1) - (a.1 - o.1) * (b.0 - o.0)
+    }
+
+    let mut hull = Vec::new();
+    for &p in &sorted_poses {
+        while hull.len() >= 2 && cross_product(hull[hull.len() - 2], hull[hull.len() - 1], p) <= 0.0
+        {
+            hull.pop();
+        }
+        hull.push(p);
+    }
+    let lower_len = hull.len();
+    for i in (0..sorted_poses.len() - 1).rev() {
+        let p = sorted_poses[i];
+        while hull.len() > lower_len
+            && cross_product(hull[hull.len() - 2], hull[hull.len() - 1], p) <= 0.0
+        {
+            hull.pop();
+        }
+        hull.push(p);
+    }
+    hull.pop();
+
+    let dist_sq = |p1: (f64, f64), p2: (f64, f64)| (p1.0 - p2.0).powi(2) + (p1.1 - p2.1).powi(2);
+
+    let mut min_max_dist_sq = f64::MAX;
+    let mut best_pos = poses[0];
+
+    for &p in poses {
+        let mut max_d_sq = 0.0;
+        for &h in &hull {
+            let d_sq = dist_sq(p, h);
+            if d_sq > max_d_sq {
+                max_d_sq = d_sq;
+            }
+        }
+
+        if max_d_sq < min_max_dist_sq {
+            min_max_dist_sq = max_d_sq;
+            best_pos = p;
+        }
+    }
+
+    best_pos
+}
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+
+    let n = line.trim().parse::<usize>().unwrap();
+
+    let mut poses_infra = (0..n)
+        .map(|_| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            let mut iter = line.split(' ').map(|s| s.trim().parse::<f64>().unwrap());
+
+            let (a, b) = (iter.next().unwrap(), iter.next().unwrap());
+            (a, b)
+        })
+        .collect::<Vec<(f64, f64)>>();
+
+    let res = optimized_pos(&mut poses_infra);
+    println!("{:.7} {:.7}", res.0, res.1);
+}

storage/zeta/rs/completed/27634.rs

@@ -0,0 +1,37 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    
+    let mut iter = line.split_whitespace();
+    
+    let k: i64 = iter.next().unwrap().parse().unwrap();
+    let s: i64 = iter.next().unwrap().parse().unwrap();
+    let n: i64 = iter.next().unwrap().parse().unwrap();
+
+    if n < s * k {
+        println!("NO");
+        return;
+    }
+
+    if k == 2 {
+        if n % 2 == 0 {
+            println!("YES");
+        } else {
+            println!("NO");
+        }
+    } else {
+        if s == 1 {
+            if n <= 2 * k - 2 {
+                println!("YES");
+            } else if n % 2 == 0 {
+                println!("YES");
+            } else {
+                println!("NO");
+            }
+        } else {
+            println!("YES");
+        }
+    }
+}

storage/zeta/rs/completed/3086.rs

@@ -0,0 +1,46 @@
+use std::{
+    io::{read_to_string, stdin},
+    usize,
+};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (n, m) = {
+        let (x, y) = (iter.next().unwrap(), iter.next().unwrap());
+        if x >= y { (x, y) } else { (y, x) }
+    };
+
+    let mut dp = vec![vec![0; n + 1]; n + 1];
+
+    for i in 1..=m {
+        dp[1][i] = i;
+        dp[i][i] = 1;
+    }
+
+    for i in 1..=n {
+        dp[i][1] = i;
+    }
+
+    for i in 2..=n {
+        for j in 2..=m {
+            if dp[i][j] > 0 {
+                continue;
+            }
+            let mut a = usize::MAX;
+            for x in 1..=i / 2 {
+                a = a.min(dp[i - x][j] + dp[x][j]);
+            }
+            for x in 1..=j / 2 {
+                a = a.min(dp[i][j - x] + dp[i][x]);
+            }
+            dp[i][j] = a;
+            dp[j][i] = a;
+        }
+    }
+
+    println!("{}", dp[n][m]);
+}

storage/zeta/rs/completed/31846.rs

@@ -0,0 +1,43 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+
+    stdin().read_line(&mut line).unwrap();
+
+    let _ = line.trim().parse::<usize>().unwrap();
+
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let s = line.trim().chars().collect::<Vec<char>>();
+
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let q = line.trim().parse::<usize>().unwrap();
+
+    let queries = (0..q).map(|_| {
+        line.clear();
+        stdin().read_line(&mut line).unwrap();
+        let mut parts = line.trim().split_whitespace();
+        let l = parts.next().unwrap().parse::<usize>().unwrap() - 1;
+        let r = parts.next().unwrap().parse::<usize>().unwrap() - 1;
+        (l, r)
+    });
+
+    for (l, r) in queries {
+        let len = r - l + 1;
+        let sub = &s[l..=r];
+
+        let mut max_score = 0;
+        for k in 1..len {
+            let mut score = 0;
+            for i in 0..k.min(len - k) {
+                if sub[k - 1 - i] == sub[k + i] {
+                    score += 1;
+                }
+            }
+            max_score = max_score.max(score);
+        }
+        println!("{}", max_score);
+    }
+}

storage/zeta/rs/completed/7695.rs

@@ -0,0 +1,39 @@
+use std::cmp::max;
+use std::io::stdin;
+
+fn longest_sub_regular_bracket_string(s: String) -> usize {
+    let n = s.len();
+    let mut dp = vec![vec![0; n]; n];
+
+    for dx in 1..n {
+        for left in 0..n - dx {
+            let right = left + dx;
+            if (s.as_bytes()[left] == b'(' && s.as_bytes()[right] == b')')
+                || (s.as_bytes()[left] == b'[' && s.as_bytes()[right] == b']')
+            {
+                dp[left][right] = dp[left + 1][right - 1] + 2;
+            }
+            for k in left..right {
+                dp[left][right] = max(dp[left][right], dp[left][k] + dp[k + 1][right]);
+            }
+        }
+    }
+
+    dp[0][n - 1]
+}
+
+fn main() {
+    let mut line = String::new();
+
+    loop {
+        line.clear();
+        stdin().read_line(&mut line).unwrap();
+        if line.starts_with("end") {
+            break;
+        }
+
+        let s = line.trim().to_string();
+
+        println!("{}", longest_sub_regular_bracket_string(s));
+    }
+}