abc292 a, b, c, d, e

abc292/src/bin/b.rs

@@ -6,19 +6,13 @@ fn main() {
         q: usize,
         tx: [(usize, Usize1); q],
     };
+
     let mut count = vec![0_usize; n];
     for (t, x) in tx {
         match t {
-            1 => {
-                count[x] += 1;
-            }
-            2 => {
-                count[x] += 2;
-            }
-            3 => {
-                let ans = count[x] >= 2;
-                println!("{}", if ans { "Yes" } else { "No" });
-            }
+            1 => count[x] += 1,
+            2 => count[x] += 2,
+            3 => println!("{}", if count[x] >= 2 { "Yes" } else { "No" }),
             _ => unreachable!(),
         }
     }

abc292/src/bin/c.rs

@@ -13,23 +13,22 @@ fn divisors(n: usize) -> Vec<usize> {
             }
         }
     }
-    d.sort();
+    // d.sort();
     d
 }
 
 fn main() {
     input! {
         n: usize,
     };
-    let mut ds = vec![vec![]; n + 1];
+    let mut count = vec![0_usize; n + 1];
     for x in 1..=n {
-        ds[x] = divisors(x);
+        count[x] = divisors(x).len();
     }
-
     let mut ans = 0_usize;
-    for x in 0..=n {
+    for x in 1..=n {
         let y = n - x;
-        ans += ds[x].len() * ds[y].len();
+        ans += count[x] * count[y];
     }
     println!("{}", ans);
 }

abc292/src/bin/d.rs

@@ -8,41 +8,26 @@ fn main() {
         uv: [(Usize1, Usize1); m],
     };
 
-    let mut count = vec![0_usize; n];
     let mut edges = vec![vec![]; n];
-    for (u, v) in uv.iter().copied() {
-        if u != v {
-            edges[u].push(v);
-            edges[v].push(u);
-        } else {
-            count[u] += 1;
-        }
-    }
-
     let mut dsu = Dsu::new(n);
     for (u, v) in uv.iter().copied() {
         dsu.merge(u, v);
+        edges[u].push(v);
+        edges[v].push(u);
     }
-
-    let mut ans = true;
     for group in dsu.groups() {
-        let mut c = 0_usize;
-        for u in group.iter().copied() {
-            c += edges[u].len();
-        }
-
-        c /= 2;
-        for u in group.iter().copied() {
-            c += count[u];
+        let count_v = group.len();
+        let mut count_e = 0_usize;
+        for g in group {
+            count_e += edges[g].len();
         }
-
-        if group.len() != c {
-            ans = false;
-            break;
+        if count_v * 2 != count_e {
+            println!("No");
+            return;
         }
     }
 
-    println!("{}", if ans { "Yes" } else { "No" });
+    println!("Yes");
 }
 
 //https://github.com/rust-lang-ja/ac-library-rs

abc292/src/bin/e.rs

@@ -1,10 +1,37 @@
+use std::collections::VecDeque;
+
 use proconio::{input, marker::Usize1};
 
 fn main() {
     input! {
         n: usize,
-        a: [Usize1; n],
+        m: usize,
+        uv: [(Usize1, Usize1); m],
     };
-    let ans = n - a.len();
+    let mut edges = vec![vec![]; n];
+    for (u, v) in uv {
+        edges[u].push(v);
+    }
+
+    let mut all = 0_usize;
+    for start in 0..n {
+        let mut used = vec![false; n];
+        used[start] = true;
+        let mut count = 0_usize;
+        let mut deque = edges[start].iter().copied().collect::<VecDeque<usize>>();
+        while let Some(u) = deque.pop_front() {
+            if used[u] {
+                continue;
+            }
+            used[u] = true;
+            count += 1;
+            for v in edges[u].iter().copied() {
+                deque.push_back(v);
+            }
+        }
+        all += count;
+    }
+
+    let ans = all - m;
     println!("{}", ans);
 }