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

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