#149452 (Rust) No.483 マッチ並べ

• 問題: No.483 マッチ並べ
• ユーザー: mio_h
• 提出日時: 2017-02-11 00:39:52
• 言語: Rust (1.77.0 + proconio)
• 結果: AC
• 実行時間: 2 ms / 2,000 ms
• コード長: 3,950 bytes
• コンパイル時間: 13,708 ms
• コンパイル使用メモリ: 379,976 KB
• 実行使用メモリ: 5,376 KB
• 最終ジャッジ日時: 2024-06-09 07:56:09
• 合計ジャッジ時間: 15,545 ms
• ジャッジサーバーID （参考情報）: judge4 / judge1

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	1 ms; 5,248 KB
testcase_01	AC	1 ms; 5,248 KB
testcase_02	AC	1 ms; 5,376 KB
testcase_03	AC	1 ms; 5,376 KB
testcase_04	AC	1 ms; 5,376 KB
testcase_05	AC	1 ms; 5,376 KB
testcase_06	AC	1 ms; 5,376 KB
testcase_07	AC	1 ms; 5,376 KB
testcase_08	AC	1 ms; 5,376 KB
testcase_09	AC	1 ms; 5,376 KB
testcase_10	AC	1 ms; 5,376 KB
testcase_11	AC	1 ms; 5,376 KB
testcase_12	AC	1 ms; 5,376 KB
testcase_13	AC	1 ms; 5,376 KB
testcase_14	AC	1 ms; 5,376 KB
testcase_15	AC	2 ms; 5,376 KB
testcase_16	AC	1 ms; 5,376 KB
testcase_17	AC	1 ms; 5,376 KB
testcase_18	AC	1 ms; 5,376 KB
testcase_19	AC	2 ms; 5,376 KB
testcase_20	AC	1 ms; 5,376 KB
testcase_21	AC	1 ms; 5,376 KB
testcase_22	AC	1 ms; 5,376 KB
testcase_23	AC	1 ms; 5,376 KB
testcase_24	AC	1 ms; 5,376 KB
testcase_25	AC	1 ms; 5,376 KB
testcase_26	AC	1 ms; 5,376 KB
testcase_27	AC	1 ms; 5,376 KB
testcase_28	AC	1 ms; 5,376 KB
testcase_29	AC	1 ms; 5,376 KB
testcase_30	AC	2 ms; 5,376 KB
testcase_31	AC	1 ms; 5,376 KB
testcase_32	AC	1 ms; 5,376 KB
testcase_33	AC	1 ms; 5,376 KB
testcase_34	AC	1 ms; 5,376 KB
testcase_35	AC	1 ms; 5,376 KB
testcase_36	AC	1 ms; 5,376 KB
testcase_37	AC	1 ms; 5,376 KB
testcase_38	AC	1 ms; 5,376 KB
testcase_39	AC	1 ms; 5,376 KB
testcase_40	AC	1 ms; 5,376 KB
testcase_41	AC	1 ms; 5,376 KB
testcase_42	AC	1 ms; 5,376 KB
testcase_43	AC	1 ms; 5,376 KB
testcase_44	AC	1 ms; 5,376 KB
testcase_45	AC	2 ms; 5,376 KB
testcase_46	AC	1 ms; 5,376 KB
testcase_47	AC	1 ms; 5,376 KB
testcase_48	AC	1 ms; 5,376 KB
testcase_49	AC	1 ms; 5,376 KB
testcase_50	AC	1 ms; 5,376 KB
testcase_51	AC	1 ms; 5,376 KB
testcase_52	AC	1 ms; 5,376 KB
testcase_53	AC	1 ms; 5,376 KB
testcase_54	AC	1 ms; 5,376 KB
testcase_55	AC	1 ms; 5,376 KB

コンパイルメッセージ

warning: use of deprecated method `std::error::Error::description`: use the Display impl or to_string()
   --> src/main.rs:126:62
    |
126 |             Err(why) => panic!("error in read_line: {}", why.description()),
    |                                                              ^^^^^^^^^^^
    |
    = note: `#[warn(deprecated)]` on by default

ソースコード

use std::io::{self, Stdin};
use std::str::{self, FromStr};
use std::error::Error;
use std::thread;
use std::collections::*;

fn exec() {
    let mut sc = Scanner::new();
    let n: usize = sc.ne();
    let mut edge = vec![(0, 0); n];
    let mut num = BTreeMap::new();
    for i in 0..n {
        let y1: usize = sc.ne::<usize>() - 1;
        let x1: usize = sc.ne::<usize>() - 1;
        let y2: usize = sc.ne::<usize>() - 1;
        let x2: usize = sc.ne::<usize>() - 1;
        let n1 = y1 * 100 + x1;
        let n2 = y2 * 100 + x2;
        edge[i] = (n1, n2);
        num.insert(n1, 0);
        num.insert(n2, 0);
    }
    let mut t = 0;
    for (_, val) in num.iter_mut() {
        *val = t;
        t += 1;
    }
    let m = num.len();
    let mut uf = UnionFind::new(m);
    for &(u_, v_) in &edge {
        let u = num[&u_];
        let v = num[&v_];
        uf.unite(u, v);
    }
    let mut cnt = vec![0; m];
    for &(u_, _) in &edge {
        let u = num[&u_];
        cnt[uf.root(u)] += 1;
    }
    let mut ok = true;
    for i in 0..m {
        if uf.root(i) == i {
            ok &= cnt[i] <= uf.size(i);
        }
    }
    println!("{}", if ok { "YES" } else { "NO" });
}

struct UnionFind {
    data: Vec<i32>,
    group: usize,
}
#[allow(dead_code)]
impl UnionFind {
    fn new(n: usize) -> UnionFind {
        UnionFind {
            data: vec![-1i32; n],
            group: n,
        }
    }

    //経路圧縮のみ
    fn unite(&mut self, x: usize, y: usize) -> bool {
        let x = self.root(x);
        let y = self.root(y);
        if x == y {
            return false;
        }
        self.data[x] += self.data[y];
        self.data[y] = x as i32;
        self.group -= 1;
        true
    }

    fn root(&mut self, x: usize) -> usize {
        if self.data[x] < 0 {
            x
        } else {
            let par = self.data[x] as usize;
            let res = self.root(par);
            self.data[x] = res as i32;
            res
        }
    }

    fn same(&mut self, x: usize, y: usize) -> bool {
        self.root(x) == self.root(y)
    }

    fn size(&mut self, x: usize) -> i32 {
        let par = self.root(x);
        -self.data[par]
    }
}


const DEFAULT_STACK: usize = 16 * 1024 * 1024;
fn main() {
    let builder = thread::Builder::new();
    let th = builder.stack_size(DEFAULT_STACK);
    let handle = th.spawn(|| { exec(); }).unwrap();
    let _ = handle.join();
}

#[allow(dead_code)]
struct Scanner {
    stdin: Stdin,
    id: usize,
    buf: Vec<u8>,
}

#[allow(dead_code)]
impl Scanner {
    fn new() -> Scanner {
        Scanner {
            stdin: io::stdin(),
            id: 0,
            buf: Vec::new(),
        }
    }
    fn next_line(&mut self) -> Option<String> {
        let mut res = String::new();
        match self.stdin.read_line(&mut res) {
            Ok(0) => return None,
            Ok(_) => Some(res),
            Err(why) => panic!("error in read_line: {}", why.description()),
        }
    }
    fn next<T: FromStr>(&mut self) -> Option<T> {
        while self.buf.len() == 0 {
            self.buf = match self.next_line() {
                Some(r) => {
                    self.id = 0;
                    r.trim().as_bytes().to_owned()
                }
                None => return None,
            };
        }
        let l = self.id;
        assert!(self.buf[l] != b' ');
        let n = self.buf.len();
        let mut r = l;
        while r < n && self.buf[r] != b' ' {
            r += 1;
        }
        let res = match str::from_utf8(&self.buf[l..r]).ok().unwrap().parse::<T>() {
            Ok(s) => Some(s),
            Err(_) => panic!("parse error"),
        };
        while r < n && self.buf[r] == b' ' {
            r += 1;
        }
        if r == n {
            self.buf.clear();
        } else {
            self.id = r;
        }
        res
    }
    fn ne<T: FromStr>(&mut self) -> T {
        self.next::<T>().unwrap()
    }
}