Maalaus

use std::io;
use std::collections::HashMap;

fn main() {
    let mut input: String = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let input: Vec<usize> = input.trim().split(" ").map(|s| s.parse::<usize>().unwrap()).collect();

    let operations: (HashMap<String, (usize, usize)>, HashMap<usize, String>) = parse_operations(&input);
    count_colors(operations.0, operations.1, input);
}

fn parse_operations(input: &Vec<usize>) -> (HashMap<String, (usize, usize)>, HashMap<usize, String>) {
    let mut operations: HashMap<String, (usize, usize)> = HashMap::new();
    let mut operation_order: HashMap<usize, String> = HashMap::new();

    for i in 0..input[3] {
        let mut operation: String = String::new();
        io::stdin().read_line(&mut operation).unwrap();
        let operation: Vec<&str> = operation.trim().split(" ").collect();
        
        let key: String = format!("{}{}", operation[0], operation[1]);
        let color: usize = operation[2].parse::<usize>().unwrap();
        match operations.get_mut(&key) {
            Some(o) => {
                operation_order.remove(&o.1);
                *o = (color, i);
            }
            None => {
                operations.insert(key.clone(), (color, i));
            }
        }
        operation_order.insert(i, key);
    }

    return (operations, operation_order);
}

fn count_colors(operations: HashMap<String, (usize, usize)>, operation_order: HashMap<usize, String>, input: Vec<usize>) {
    let mut colors: HashMap<usize, usize> = HashMap::new();

    for i in 0..input[3] {
        match operation_order.get(&i) {
            Some(operation_id) => {
                let color_id: &(usize, usize) = operations.get(operation_id).unwrap();
                let amount: usize = if operation_id.starts_with("R") { input[1] } else { input[0] };
                let current_type: char = operation_id.chars().next().unwrap();
                match colors.get_mut(&color_id.0) {
                    Some(color) => { *color += amount; }
                    None => { colors.insert(color_id.0, amount); }
                }
                colors = iterate_previous(colors, &operations, &operation_order, i, current_type)
            }
            None => { continue; }
        }
    }
    print_result(colors, input[2]);
}

fn iterate_previous(mut colors: HashMap<usize, usize>, operations: &HashMap<String, (usize, usize)>, operation_order: &HashMap<usize, String>, i: usize, current_type: char) -> HashMap<usize, usize> {
    for j in 0..i {
        match operation_order.get(&j) {
            Some(operation_id) => {
                let color_id = operations.get(operation_id).unwrap();
                let operation_type: char = operation_id.chars().next().unwrap();
                if operation_type != current_type {
                    *colors.get_mut(&color_id.0).unwrap() -= 1;
                }
            }
            None => { continue; }
        }
    }
    return colors;
}

fn print_result(colors: HashMap<usize, usize>, k: usize) {
    for i in 0..k {
        match colors.get(&(i+1)) {
            Some(color) => { print!("{color} "); }
            None => { print!("0 "); }
        }
    }
}

Test 1 (public)

Group: 1, 3, 4

Verdict: ACCEPTED

Test 2 (public)

Group: 3, 4

Verdict: ACCEPTED

Test 3

Group: 1, 3, 4

Verdict: ACCEPTED

Test 4

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 3, 4

Verdict: ACCEPTED

Test 7

Group: 3, 4

Verdict: ACCEPTED

Test 8

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 1, 3, 4

Verdict: ACCEPTED

Test 11

Group: 1, 3, 4

Verdict: ACCEPTED

Test 12

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2, 4

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 4

Verdict: TIME LIMIT EXCEEDED