// ____ _ _ _ _ // | _ \ _ _ ___| |_ ___ _ __ | |_ ___ _ __ ___ _ __ | | __ _| |_ ___ // | |_) | | | / __| __| / __| '_ \ | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \ // | _ <| |_| \__ \ |_ | (__| |_) | | || __/ | | | | | |_) | | (_| | || __/ // |_| \_\\__,_|___/\__| \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___| // |_| |_____| |_| //https://github.com/manta1130/Competitive_Programming_Template_Rust #[macro_use] mod input { use std; use std::io; const SPLIT_DELIMITER: char = ' '; #[macro_export] #[allow(unused_macros)] macro_rules! input { ( $($x:expr ),*) => { { let temp_str = input_line_str(); let mut split_result_iter = temp_str.split_whitespace(); $( let buf_split_result = split_result_iter.next(); let buf_split_result = buf_split_result.unwrap(); ($x) = buf_split_result.parse().unwrap(); )* } }; } #[allow(dead_code)] pub fn input_line_str() -> String { let mut s = String::new(); io::stdin().read_line(&mut s).unwrap(); s.trim().to_string() } #[allow(dead_code)] pub fn p(t: T) where T: std::fmt::Display, { println!("{}", t); } #[allow(dead_code)] pub fn input_vector2d(line: usize) -> Vec> where T: std::str::FromStr, { let mut v: Vec> = Vec::new(); for _ in 0..line { let vec_line = input_vector(); v.push(vec_line); } v } #[allow(dead_code)] pub fn input_vector() -> Vec where T: std::str::FromStr, { let mut v: Vec = Vec::new(); let s = input_line_str(); let split_result = s.split(SPLIT_DELIMITER); for z in split_result { let buf = match z.parse() { Ok(r) => r, Err(_) => panic!("Parse Error"), }; v.push(buf); } v } #[allow(dead_code)] pub fn input_vector_row(n: usize) -> Vec where T: std::str::FromStr, { let mut v = Vec::with_capacity(n); for _ in 0..n { let buf = match input_line_str().parse() { Ok(r) => r, Err(_) => panic!("Parse Error"), }; v.push(buf); } v } pub trait ToCharVec { fn to_charvec(&self) -> Vec; } impl ToCharVec for String { fn to_charvec(&self) -> Vec { self.to_string().chars().collect::>() } } } use input::*; const Y: usize = 0; const K: usize = 1; const C: usize = 2; const N: usize = 3; fn main() { let (n, m): (usize, usize); input!(n, m); let bs = (n as f64).sqrt() as usize; let mut ans = vec![0; 3]; let mut v = vec![N; n]; let mut b = vec![0; bs + 2]; for _ in 0..m { let (l, r, t): (usize, usize, char); input!(l, r, t); let t = match t { 'Y' => Y, 'K' => K, _ => C, }; let mut i = l - 1; while i < r { //p(i); if i % bs == 0 && i + bs < r && b[i / bs] == bs { i += bs; } else if i % bs == 0 && i + bs < r && b[i / bs] == 0 { b[i / bs] = bs; ans[t] += bs; i += bs; } else { if v[i] == N && b[i / bs] != bs { v[i] = t; b[i / bs] += 1; ans[t] += 1; } i += 1; } } } println!("{} {} {}", ans[0], ans[1], ans[2]); }