#1157922 (Rust) No.3503 Brackets Stack Query 2

• 問題: No.3503 Brackets Stack Query 2
• ユーザー: akakimidori
• 提出日時: 2026-04-17 21:22:45
• 言語: Rust (1.94.0 + proconio + num + itertools)
• 結果: AC
• 実行時間: 195 ms / 2,000 ms
• コード長: 4,228 bytes
• コンパイル時間: 2,945 ms
• コンパイル使用メモリ: 201,616 KB
• 実行使用メモリ: 55,168 KB
• 最終ジャッジ日時: 2026-04-17 21:23:08
• 合計ジャッジ時間: 14,008 ms
• ジャッジサーバーID （参考情報）: judge1_1 / judge3_0

ファイルパターン	結果
sample	AC * 1
other	AC * 30

コンパイルメッセージ

warning: type alias `Map` is never used
  --> src/main.rs:57:6
   |
57 | type Map<K, V> = BTreeMap<K, V>;
   |      ^^^
   |
   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: type alias `Set` is never used
  --> src/main.rs:58:6
   |
58 | type Set<T> = BTreeSet<T>;
   |      ^^^

warning: type alias `Deque` is never used
  --> src/main.rs:59:6
   |
59 | type Deque<T> = VecDeque<T>;
   |      ^^^^^

ソースコード

fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    let q: usize = sc.next();
    type S = persistent_stack::Stack<char>;
    let mut stack = vec![S::new()];
    for _ in 0..q {
        let op = sc.next::<u32>();
        if op == 1 {
            let c = sc.next::<String>();
            let c = c.chars().next().unwrap();
            let mut p = stack.last().unwrap().push(c);
            if p.iter().cloned().take(3).collect::<Vec<_>>() == vec![')', '|', '('] {
                for _ in 0..3 {
                    p = p.pop().unwrap().0;
                }
            }
            stack.push(p);
        } else {
            stack.pop();
        }
        writeln!(out, "{}", if stack.last().unwrap().is_empty() {"Yes"} else {"No"}).ok();
    }
}

// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::io::Write;
use std::collections::*;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}
// ---------- begin persistent stack ----------
#[allow(dead_code)]
mod persistent_stack {
    use std::rc::Rc;

    type Ref<T> = Rc<Node<T>>;
    type Link<T> = Option<Ref<T>>;

    struct Node<T> {
        value: T,
        next: Link<T>,
    }

    impl<T> Node<T> {
        fn new(value: T, next: Link<T>) -> Self {
            Node { value, next }
        }
    }

    #[derive(Clone)]
    pub struct Stack<T> {
        size: usize,
        node: Link<T>,
    }

    impl<T> Drop for Stack<T> {
        fn drop(&mut self) {
            let mut root = self.node.take();
            while let Some(Some(node)) = root.as_mut().map(|p| Rc::get_mut(p)) {
                root = node.next.take();
            }
        }
    }

    impl<T> Stack<T> {
        fn build(size: usize, node: Link<T>) -> Self {
            Stack { size, node }
        }
        pub fn new() -> Self {
            Stack::build(0, None)
        }
        #[must_use]
        pub fn push(&self, value: T) -> Self {
            let node = Some(Rc::new(Node::new(value, self.node.clone())));
            Stack::build(self.size + 1, node)
        }
        pub fn top(&self) -> Option<&T> {
            self.node.as_ref().map(|p| &p.value)
        }
        #[must_use]
        pub fn pop(&self) -> Option<(Self, &T)> {
            self.node.as_ref().map(|p| {
                let s = Stack::build(self.size - 1, p.next.clone());
                (s, &p.value)
            })
        }
        pub fn len(&self) -> usize {
            self.size
        }
        pub fn is_empty(&self) -> bool {
            self.size == 0
        }
    }

    pub struct Iter<'a, T> {
        next: Option<&'a Ref<T>>,
    }

    impl<T> Stack<T> {
        pub fn iter(&self) -> Iter<'_, T> {
            Iter {
                next: self.node.as_ref(),
            }
        }
    }

    impl<'a, T> Iterator for Iter<'a, T> {
        type Item = &'a T;
        fn next(&mut self) -> Option<Self::Item> {
            self.next.take().map(|p| {
                self.next = p.next.as_ref();
                &p.value
            })
        }
    }
}
// ---------- end persistent stack ----------