AtCoder Beginner Contest 441 D

https://atcoder.jp/contests/abc441/tasks/abc441_d

辺を辿るだけですね。

// Paid Walk
#![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()
}


//////////////////// Graph ////////////////////

type Node = usize;
type Weight = i32;
type Edge = (Node, Node, Weight);

fn read_edge() -> Edge {
    let v: Vec<usize> = read_vec();
    let (U, V, C) = (v[0]-1, v[1]-1, v[2] as Weight);
    (U, V, C)
}

struct Graph {
    g: Vec<Vec<(Node, Weight)>>
}

impl Graph {
    fn create_from_edges(N: usize, edges: Vec<Edge>) -> Graph {
        let mut g: Vec<Vec<(Node, Weight)>> = vec![vec![]; N];
        for (U, V, C) in edges {
            g[U].push((V, C))
        }
        Graph { g }
    }
}


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

use std::collections::BTreeSet;

fn read_input() -> (usize, usize, Weight, Weight, Vec<Edge>) {
    let v: Vec<usize> = read_vec();
    let (N, M, L, S, T) = (v[0], v[1], v[2], v[3] as Weight, v[4] as Weight);
    let edges: Vec<Edge> = (0..M).map(|_| read_edge()).collect();
    (N, L, S, T, edges)
}

fn F(N: usize, L: usize, S: Weight, T: Weight, edges: Vec<Edge>) {
    let graph = Graph::create_from_edges(N, edges);
    let mut vs: Vec<(Node, Weight)> = vec![(0, 0)];
    for _ in 0..L {
        let mut new_vs: Vec<(Node, Weight)> = vec![];
        for (v, c) in vs {
            for &(v1, c1) in graph.g[v].iter() {
                if c+c1 <= T {
                    new_vs.push((v1, c+c1))
                }
            }
        }
        vs = new_vs
    }
    let nodes: BTreeSet<Node> = vs.into_iter().
                                        filter(|&(_, c)| c >= S).
                                        map(|(v, _)| v).collect();
    println!("{}", nodes.into_iter().map(|v| (v+1).to_string()).
                                    collect::<Vec<_>>().join(" "));
}

fn main() {
    let (N, L, S, T, edges) = read_input();
    F(N, L, S, T, edges)
}