Laskettelukeskus

#![recursion_limit = "120000"]
use std::cmp::max;
use std::io::stdin;
 
#[derive(Clone, Debug)]
struct Slope {
    children: Vec<usize>,
    plough_demand: u32
}
impl Slope {
    pub const DUMMY: Self = Self {
        children: Vec::new(),
        plough_demand: 0
    };
}
 
//possible stack overflow
fn get_total_plough_demand(parent_index: usize, all_slopes: &Vec<Slope>) -> u32 {
    let demand_of_children: u32 = all_slopes[parent_index].children
        .iter()
        .map(|&i| get_total_plough_demand(i, all_slopes))
        .sum();
    let demand_of_parent = all_slopes[parent_index].plough_demand;
 
    max(demand_of_children, demand_of_parent)
}
 
fn main() {
    let mut input = stdin().lines();
 
    let line = input.next().unwrap().unwrap();
    let slope_count: usize = line.parse().unwrap();
    let mut slopes = vec![Slope::DUMMY; slope_count];
 
    for line in (&mut input).take(slope_count - 1) {
        let indeces: Vec<usize> = line
            .unwrap()
            .split_whitespace()
            .map(|s| s.parse().unwrap())
            .map(|i: usize| i - 1)
            .collect();
 
        slopes[indeces[0]].children.push(indeces[1]);
    }
 
    let line = input.next().unwrap().unwrap();
    let plough_demands = line
        .split_whitespace()
        .map(|s| s.parse().unwrap());
    for (i, plough_demand) in plough_demands.enumerate() {
        slopes[i].plough_demand = plough_demand;
    }
 
    println!("{}", get_total_plough_demand(0, &slopes));
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 2

Verdict: WRONG ANSWER

Test 5

Group: 2

Verdict: WRONG ANSWER

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 2

Verdict: ACCEPTED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 2

Verdict: ACCEPTED

Test 10

Group: 1, 2

Verdict: ACCEPTED

Test 11

Group: 2

Verdict: WRONG ANSWER

Test 12

Group: 1, 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: WRONG ANSWER