Maalaus

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

fn read_next<'a, I>(iter: &mut I) -> u32
where
    I: Iterator<Item = &'a str>,
{
    iter.next()
        .expect("invalid input")
        .parse::<u32>()
        .expect("invalid integer")
}

fn main() {
    // Input
    let mut nmkq = String::new();
    io::stdin()
        .read_line(&mut nmkq)
        .expect("failed to read line");
    let mut nmk = nmkq.split_ascii_whitespace();
    let n = read_next(&mut nmk);
    let m = read_next(&mut nmk);
    let k = read_next(&mut nmk);
    let q = read_next(&mut nmk);

    let mut row_ops: HashMap<u32, (u32, u32)> = HashMap::new(); // row: time, color
    let mut col_ops: HashMap<u32, (u32, u32)> = HashMap::new(); // col: time, color
    let mut k_1_sum: u128 = 0; // If k=1

    for t in 0..q {
        let mut oic = String::new();
        io::stdin()
            .read_line(&mut oic)
            .expect("failed to read line");
        let mut oic = oic.split_ascii_whitespace();
        let o = oic.next().expect("too few arguments");
        let i = read_next(&mut oic);
        let c = read_next(&mut oic);
        if k > 1 {
            match o {
                "R" => row_ops.insert(i - 1, (t, c - 1)),
                "C" => col_ops.insert(i - 1, (t, c - 1)),
                _ => panic!("illegal operation '{o}'"),
            };
        } else {
            match o {
                "R" => {
                    let res = row_ops.insert(i - 1, (t, c - 1));
                    if res.is_none() {
                        k_1_sum += (m as usize - col_ops.len()) as u128;
                    }
                },
                "C" => {
                    let res = col_ops.insert(i - 1, (t, c - 1));
                    if res.is_none() {
                        k_1_sum += (n as usize - row_ops.len()) as u128;
                    }
                },
                _ => panic!("illegal operation '{o}'"),
            };
        }
    }

    if k > 1 {
        let mut sums: Vec<u128> = vec![0; k as usize];
        // Rows
        for (r_time, r_color) in row_ops.values() {
            sums[*r_color as usize] += m as u128;
            col_ops
                .values()
                .filter(|(x_time, _)| x_time > r_time)
                .for_each(|_| {
                    sums[*r_color as usize] -= 1;
                });
        }
        // Cols
        for (c_time, c_color) in col_ops.values() {
            sums[*c_color as usize] += n as u128;
            row_ops
                .values()
                .filter(|(x_time, _)| x_time > c_time)
                .for_each(|_| {
                    sums[*c_color as usize] -= 1;
                });
        }
        for sum in sums {
            print!("{sum} ");
        }
        println!();
    } else {
        println!("{k_1_sum}")
    }
}

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: ACCEPTED

Test 5

Group: 2, 4

Verdict: ACCEPTED

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: ACCEPTED

Test 13

Group: 2, 4

Verdict: ACCEPTED

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