Problem:
Score : 500 points

Problem Statement

AtCoDeer is thinking of painting an infinite two-dimensional grid in a checked pattern of side K.
Here, a checked pattern of side K is a pattern where each square is painted black or white so that each connected component of each color is a K × K square.
Below is an example of a checked pattern of side 3:

AtCoDeer has N desires.
The i-th desire is represented by x_i, y_i and c_i.
If c_i is B, it means that he wants to paint the square (x_i,y_i) black; if c_i is W, he wants to paint the square (x_i,y_i) white.
At most how many desires can he satisfy at the same time?

Constraints

1 ≤ N ≤ 10^5

1 ≤ K ≤ 1000

0 ≤ x_i ≤ 10^9

0 ≤ y_i ≤ 10^9

If i ≠ j, then (x_i,y_i) ≠ (x_j,y_j).

c_i is B or W.

N, K, x_i and y_i are integers.

Input

Input is given from Standard Input in the following format:

N K
x_1 y_1 c_1
x_2 y_2 c_2
:
x_N y_N c_N

Output

Print the maximum number of desires that can be satisfied at the same time.

Sample Input 1

4 3
0 1 W
1 2 W
5 3 B
5 4 B

Sample Output 1

4

He can satisfy all his desires by painting as shown in the example above.

Sample Input 2

2 1000
0 0 B
0 1 W

Sample Output 2

2

Sample Input 3

6 2
1 2 B
2 1 W
2 2 B
1 0 B
0 6 W
4 5 W

Sample Output 3

4

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    /*
    2K * 2K 通り試す.座標は mod 2K としてよい
    二次元累積和でよさそう
    */
    let (N, K) = (io.read::<usize>(), io.read::<usize>());
    // let mut b = vec![vec![0; 2020]; 2020];
    // let mut s = vec![vec![0; 4040]; 4040];

    let mut xy = vec![vec![0; K * 2 + 1]; K * 2 + 1];
    for i in 0..N {
        let (mut x, mut y, c) = (io.read::<usize>(), io.read::<usize>(), io.read::<char>());
        if c == 'W' {
            xy[x % (2 * K)][y % (K * 2)] += 1;
        // y += K;
        } else {
            xy[(x + K) % (K * 2)][y % (2 * K)] += 1;
        }
        // b[x % (2 * K)][y % (2 * K)] += 1;
    }

    for xx in 0..2 * K {
        for yy in 1..2 * K {
            xy[xx][yy] += xy[xx][yy - 1];
        }
    }
    for yy in 0..2 * K {
        for xx in 1..2 * K {
            xy[xx][yy] += xy[xx - 1][yy];
        }
    }
    let mut ans = 0;
    let check = |x: usize, y: usize| -> usize {
        let kk = K * 2 - 1;

        xy[kk][kk]
            + if x > 0 { xy[x - 1][kk] } else { 0 }
            + if y > 0 { xy[kk][y - 1] } else { 0 }
            + 2 * xy[x + K - 1][y + K - 1]
            + 2 * if x > 0 && y > 0 { xy[x - 1][y - 1] } else { 0 }
            - xy[x + K - 1][kk]
            - xy[kk][y + K - 1]
            - 2 * if x > 0 { xy[x - 1][y + K - 1] } else { 0 }
            - 2 * if y > 0 { xy[x + K - 1][y - 1] } else { 0 }
    };
    for xx in 0..K {
        for yy in 0..K {
            let tmp = check(xx, yy);
            ans = max(ans, tmp);
            ans = max(ans, N - tmp);
        }
    }
    io.writeln(ans);
}

static MX: usize = 1010101;
static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}