AtCoder Beginner Contest 411 D

https://atcoder.jp/contests/abc411/tasks/abc411_d

すぐにリスト構造を使えばいいとわかりますが、Rustではなかなか大変です。後ろに追加するリストは難しいので前にcharを追加して、最後に反転させて文字列を作ります。

// Conflict 2
#![allow(non_snake_case)]


//////////////////// library ////////////////////

fn read<T: std::str::FromStr>() -> T {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).ok();
    line.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect()
}


//////////////////// List ////////////////////

use std::rc::Rc;

#[derive(Clone)]
enum List<T: Copy + Clone> {
    Cons(T, Rc<List<T>>),
    Nil,
}

impl<T: Copy + Clone> List<T> {
    fn new() -> Self {
        List::Nil
    }
    
    fn push_front(&self, value: T) -> Self {
        List::Cons(value, Rc::new(self.clone()))
    }
    
    fn to_vec(&self) -> Vec<T> {
        let mut v: Vec<T> = vec![];
        let mut cur = self;
        while let List::Cons(head, tail) = cur {
            v.push(*head);
            cur = tail
        }
        v
    }
}

impl List<char> {
    fn ReplaceFromServer(p: usize, lists: &mut Vec<List<char>>) {
        lists[p] = lists[0].clone()
    }
    
    fn Add(p: usize, s: String, lists: &mut Vec<List<char>>) {
        for c in s.chars() {
            lists[p] = lists[p].clone().push_front(c)
        }
    }
    
    fn ReplaceFromClient(p: usize, lists: &mut Vec<List<char>>) {
        lists[0] = lists[p].clone()
    }
    
    fn str(&self) -> String {
        let v = self.to_vec();
        v.into_iter().rev().collect::<String>()
    }
}


//////////////////// Query ////////////////////

enum Query {
    ReplaceFromServer(usize),
    Add(usize, String),
    ReplaceFromClient(usize),
}

impl Query {
    fn read() -> Query {
        let v: Vec<String> = read_vec();
        let p: usize = v[1].parse().ok().unwrap();
        if v[0] == "1" {
            Query::ReplaceFromServer(p)
        }
        else if v[0] == "2" {
            Query::Add(p, v[2].clone())
        }
        else {
            Query::ReplaceFromClient(p)
        }
    }
}

fn query(q: Query, lists: &mut Vec<List<char>>) {
    match q {
        Query::ReplaceFromServer(p) => List::ReplaceFromServer(p, lists),
        Query::Add(p, s)            => List::Add(p, s, lists),
        Query::ReplaceFromClient(p) => List::ReplaceFromClient(p, lists)
    }
}


//////////////////// process ////////////////////

fn read_input() -> (usize, usize) {
    let v: Vec<usize> = read_vec();
    let (N, Q) = (v[0], v[1]);
    (N, Q)
}

fn F(N: usize, Q: usize) -> String {
    let mut lists: Vec<List<char>> = vec![List::new(); N+1];
    for _ in 0..Q {
        let q = Query::read();
        query(q, &mut lists)
    }
    lists[0].str()
}

fn main() {
    let (N, Q) = read_input();
    println!("{}", F(N, Q))
}