abc333 a, b, c, d, e

cargo-atcoder-1.70.0/contests/past202212-open/abc333/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "abc333"
+version = "0.1.0"
+edition = "2021"
+
+# dependencies added to new project
+[dependencies]
+ac-library-rs = "=0.1.1"
+num = "=0.4.0"
+proconio = { version = "=0.4.3", features = ["derive"] }
+superslice = "=1.0.0"
+
+[profile.release]
+lto = true
+panic = 'abort'

cargo-atcoder-1.70.0/contests/past202212-open/abc333/rust-toolchain

@@ -0,0 +1 @@
+1.70.0

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/a.rs

@@ -0,0 +1,9 @@
+use proconio::input;
+
+fn main() {
+    input! {
+        n: usize,
+    };
+    let ans = n.to_string().repeat(n);
+    println!("{}", ans);
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/b.rs

@@ -0,0 +1,33 @@
+use std::collections::HashSet;
+
+use proconio::{input, marker::Chars};
+
+fn main() {
+    input! {
+        mut s: Chars,
+        mut t: Chars,
+    };
+    if s[0] > s[1] {
+        s.swap(0, 1);
+    }
+    if t[0] > t[1] {
+        t.swap(0, 1);
+    }
+
+    let mut set1 = HashSet::new();
+    set1.insert("AB".chars().collect::<Vec<char>>());
+    set1.insert("AE".chars().collect::<Vec<char>>());
+    set1.insert("BC".chars().collect::<Vec<char>>());
+    set1.insert("CD".chars().collect::<Vec<char>>());
+    set1.insert("DE".chars().collect::<Vec<char>>());
+
+    let mut set2 = HashSet::new();
+    set2.insert("AC".chars().collect::<Vec<char>>());
+    set2.insert("AD".chars().collect::<Vec<char>>());
+    set2.insert("BD".chars().collect::<Vec<char>>());
+    set2.insert("BE".chars().collect::<Vec<char>>());
+    set2.insert("CE".chars().collect::<Vec<char>>());
+
+    let ans = (set1.contains(&s) && set1.contains(&t)) || (set2.contains(&s) && set2.contains(&t));
+    println!("{}", if ans { "Yes" } else { "No" });
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/c.rs

@@ -0,0 +1,32 @@
+use std::collections::HashSet;
+
+use proconio::{input, marker::Usize1};
+
+fn main() {
+    input! {
+        n: Usize1,
+    };
+
+    let mut rep = vec![];
+    let mut x = 1;
+    rep.push(x);
+    for _ in 0..14 {
+        x *= 10;
+        x += 1;
+        rep.push(x);
+    }
+
+    let mut set = HashSet::new();
+    for i in rep.iter().copied() {
+        for j in rep.iter().copied() {
+            for k in rep.iter().copied() {
+                set.insert(i + j + k);
+            }
+        }
+    }
+
+    let mut set = set.iter().copied().collect::<Vec<usize>>();
+    set.sort();
+    let ans = set[n];
+    println!("{}", ans);
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/d.rs

@@ -0,0 +1,41 @@
+use proconio::{input, marker::Usize1};
+
+fn dfs(size: &mut Vec<usize>, edges: &Vec<Vec<usize>>, u: usize, p: usize) {
+    for v in edges[u].iter().copied() {
+        if v == p {
+            continue;
+        }
+        dfs(size, edges, v, u);
+        size[u] += size[v];
+    }
+    size[u] += 1;
+}
+
+fn main() {
+    input! {
+        n: usize,
+        uv: [(Usize1, Usize1); n - 1],
+    };
+
+    let mut edges = vec![vec![]; n];
+    for (u, v) in uv {
+        edges[u].push(v);
+        edges[v].push(u);
+    }
+
+    if edges[0].len() == 1 {
+        println!("1");
+        return;
+    }
+
+    let mut size = vec![0; n];
+    dfs(&mut size, &edges, 0, 0);
+
+    let mut max = 0;
+    for v in edges[0].iter().copied() {
+        max = max.max(size[v]);
+    }
+
+    let ans = n - max;
+    println!("{}", ans);
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/e.rs

@@ -0,0 +1,41 @@
+use proconio::{input, marker::Usize1};
+
+fn main() {
+    input! {
+        n: usize,
+        tx: [(usize, Usize1); n],
+    };
+    let mut need_max = 0_usize;
+    let mut need_sum = 0_usize;
+    let mut need = vec![0; n];
+    let mut ans = vec![];
+    for (t, x) in tx.iter().copied().rev() {
+        match t {
+            1 => {
+                if need[x] > 0 {
+                    need[x] -= 1;
+                    need_sum -= 1;
+                    ans.push(1);
+                } else {
+                    ans.push(0);
+                }
+            }
+            2 => {
+                need[x] += 1;
+                need_sum += 1;
+                need_max = need_max.max(need_sum);
+            }
+            _ => unreachable!(),
+        }
+    }
+    if !need.iter().all(|&x| x == 0) {
+        println!("-1");
+        return;
+    }
+
+    ans.reverse();
+    println!("{}", need_max);
+    for a in ans {
+        println!("{}", a);
+    }
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/f.rs

@@ -0,0 +1,10 @@
+use proconio::{input, marker::Usize1};
+
+fn main() {
+    input! {
+        n: usize,
+        a: [Usize1; n],
+    };
+    let ans = n - a.len();
+    println!("{}", ans);
+}

cargo-atcoder-1.70.0/contests/past202212-open/abc333/src/bin/g.rs

@@ -0,0 +1,10 @@
+use proconio::{input, marker::Usize1};
+
+fn main() {
+    input! {
+        n: usize,
+        a: [Usize1; n],
+    };
+    let ans = n - a.len();
+    println!("{}", ans);
+}