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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using Map = map<ll,ll>;
using T = tuple<ll,ll,ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout<<v<<endl;
#define fi(v) get<0>(v)
#define se(v) get<1>(v)
#define th(v) get<2>(v)
template <typename T> bool chmax(T &a, const T &b){if (a<b){a=b;return 1;}return 0;}
template <typename T> bool chmin(T &a, const T &b){if (a>b){a=b;return 1;}return 0;}
const ll INF=1LL<<60;
const ll MOD=1000000007;

ll K;

vector<vector<ll>> dpb(2000, vector<ll>(2000, 0));
vector<vector<ll>> dpw(2000, vector<ll>(2000, 0));

ll Fb(ll a,ll b,ll c,ll d){
    ll bc=0,ad=0,ac=0;
    if(a)ad=dpb[a-1][d];
    if(c)bc=dpb[b][c-1];
    if(a&&c)ac=dpb[a-1][c-1];
    return dpb[b][d]-bc-ad+ac;
}
ll Fw(ll a,ll b,ll c,ll d){
    ll bc=0,ad=0,ac=0;
    if(a)ad=dpw[a-1][d];
    if(c)bc=dpw[b][c-1];
    if(a&&c)ac=dpw[a-1][c-1];
    return dpw[b][d]-bc-ad+ac;
}


int main(){
    ll N;
    cin >> N;
    ll K;
    cin >> K;
    vector<ll> X(N,0);
    vector<ll> Y(N,0);
    vector<char> C(N);
    for(ll i=0;i<N;i++)cin>>X[i]>>Y[i]>>C[i];
    vector<vector<ll>> coub(2*K, vector<ll>(2*K, 0));
    vector<vector<ll>> couw(2*K, vector<ll>(2*K, 0));
    for(ll i=0;i<N;i++){
        X[i]%=2*K;
        Y[i]%=2*K;
        if(C[i]=='B')
        coub[X[i]][Y[i]]++;
        else
        couw[X[i]][Y[i]]++;
    }
    dpb[0][0]=coub[0][0];
    dpw[0][0]=couw[0][0];
    for(ll i=1;i<2*K;i++){
        dpb[0][i]=dpb[0][i-1]+coub[0][i];
        dpw[0][i]=dpw[0][i-1]+couw[0][i];
        dpb[i][0]=dpb[i-1][0]+coub[i][0];
        dpw[i][0]=dpw[i-1][0]+couw[i][0];
    }
    for(ll i=1;i<2*K;i++)
        for(ll j=1;j<2*K;j++){
                dpb[i][j]=dpb[i-1][j]+dpb[i][j-1]-dpb[i-1][j-1]+coub[i][j];
                dpw[i][j]=dpw[i-1][j]+dpw[i][j-1]-dpw[i-1][j-1]+couw[i][j];
        }
    ll ans=0;
    for(ll i=0;i<K;i++)
        for(ll j=0;j<K;j++){
            //左下が黒
            ll sumB,sumW;
            sumB=Fb(0,i,0,j)+Fb(i+K+1,2*K-1,0,j)+Fb(i+1,i+K,j+1,j+K)
                +Fb(0,i,j+K+1,2*K-1)+Fb(i+K+1,2*K-1,j+K+1,2*K-1);
            sumW=Fw(i+1,i+K,0,j)+Fw(0,i,j+1,j+K)+Fw(i+K+1,2*K-1,j+1,j+K)+Fw(i+1,i+K,j+K+1,2*K-1);
            chmax(ans,sumB+sumW);
            
            //左下が白
            sumB=Fb(i+1,i+K,0,j)+Fb(1,i,j+1,j+K)+Fb(i+K+1,2*K-1,j+1,j+K)+Fb(i+1,i+K,j+K+1,2*K-1);
            sumW=Fw(0,i,0,j)+Fw(i+K+1,2*K-1,0,j)+Fw(i+1,i+K,j+1,j+K)
                +Fw(0,i,j+K+1,2*K-1)+Fw(i+K+1,2*K-1,j+K+1,2*K-1);
            chmax(ans,sumB+sumW);
            
        }
    print(ans)
    return 0;
}