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: Time Limit Exceeded)

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<set>
#include<map>
#include<queue>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);++i)
#define rrep(i,n) for(int (i)=(n)-1;(i)>=0;--i)
#define rep1(i,n) for(int (i)=1;(i)<=(n);++i)
#define rrep1(i,n) for(int (i)=(n);(i)>=1;--i)
#define pb push_back
#define fr first
#define sc second
typedef long long ll;
typedef pair<int,int> P;
typedef pair<long long,long long> LP;
typedef double db;
using namespace std;
ll N,K,X[100000],Y[100000];
ll B[100000];
ll b[2000];
ll w[2000];
ll ib[2000];
ll iw[2000];
ll KK;

ll IB(ll i){
  if(i<0) return 0;
  else return ib[i];
}

ll IW(ll i){
  if(i<0) return 0;
  else return iw[i];
}

ll calc(){
  rep(i,KK){
    ib[i]=iw[i]=0;
  }
  ib[0]=b[0];
  iw[0]=w[0];

  rep1(i,KK-1){
    ib[i]=ib[i-1]+b[i];
    iw[i]=iw[i-1]+w[i];
  }
  // rep(i,KK){
  //   cout<<b[i]<<" ";
  // }
  // cout<<endl;
  //
  // rep(i,KK){
  //   cout<<w[i]<<" ";
  // }
  // cout<<endl;
  ll res = 0;
  rep(i,KK){
    ll r = 0;
    if(i<K){
      r += IW(i+K-1) - IW(i-1);
      r += IB(i-1);
      r += IB(KK-1) - IB(i+K-1);
    }
    else{
      r += IW(KK-1) - IW(i-1);
      r += IB(i-1) - IB(i-K-1);
      r += IW(i-K-1);
    }
    res = max(res,r);
  }
  return res;
}

int main(){
  string s;
  cin>>N>>K;
  KK = 2*K;
  rep(i,N){
    cin>>X[i]>>Y[i]>>s;
    X[i]%=KK;
    Y[i]%=KK;
    if(s[0]=='W') B[i]=1;
    else B[i]=0;
  }
  ll ans = 0;
  rep(i,KK){
    // b.clear();
    // w.clear();
    rep(j,KK){
      b[j]=w[j]=0;
    }
    rep(j,N){
      bool q = ( ( i <= Y[j] && Y[j] < i+K ) || ( i+K > KK && Y[j] < (i+K)%KK ) );
      if(q^B[j]){
        b[X[j]]++;
      }
      else{
        w[X[j]]++;
      }
    }
    ans = max(ans,calc());
  }
  cout<<ans<<endl;
}