Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem D
Wall Clocks

You are the manager of a chocolate sales team. Your team customarily takes tea breaks every two hours, during which varieties of new chocolate products of your company are served. Everyone looks forward to the tea breaks so much that they frequently give a glance at a wall clock.

Recently, your team has moved to a new office. You have just arranged desks in the office. One team member asked you to hang a clock on the wall in front of her desk so that she will not be late for tea breaks. Naturally, everyone seconded her.

You decided to provide an enough number of clocks to be hung in the field of view of everyone. Your team members will be satisfied if they have at least one clock (regardless of the orientation of the clock) in their view, or, more precisely, within 45 degrees left and 45 degrees right (both ends inclusive) from the facing directions of their seats. In order to buy as few clocks as possible, you should write a program that calculates the minimum number of clocks needed to
meet everyone's demand.

The office room is rectangular aligned to north-south and east-west directions. As the walls are tall enough, you can hang clocks even above the door and can assume one's eyesight is not blocked by other members or furniture. You can also assume that each clock is a point (of size zero), and so you can hang a clock even on a corner of the room.

For example, assume that there are two members. If they are sitting facing each other at positions shown in Figure D.1(A), you need to provide two clocks as they see distinct sections of the wall. If their seats are arranged as shown in Figure D.1(B), their fields of view have a common point on the wall. Thus, you can meet their demands by hanging a single clock at the point. In Figure D.1(C), their fields of view have a common wall section. You can meet their demands with a single clock by hanging it anywhere in the section. Arrangements (A), (B), and (C) in Figure D.1 correspond to Sample Input 1, 2, and 3, respectively.

Input

The input consists of a single test case, formatted as follows.

$n$ $w$ $d$

$x_1$ $y_1$ $f_1$

...

$x_n$ $y_n$ $f_n$

Figure D.1. Arrangements of seats and clocks. Gray area indicates field of view.

All numbers in the test case are integers. The first line contains the number of team members $n$ $(1 \leq n \leq 1,000)$ and the size of the office room $w$ and $d$ $(2 \leq w, d \leq 100,000)$. The office room has its width $w$ east-west, and depth $d$ north-south. Each of the following $n$ lines indicates the position and the orientation of the seat of a team member. Each member has a seat at a distinct position $(x_i, y_i)$ facing the direction $f_i$, for $i = 1, ..., n$. Here $1 \leq x_i \leq w - 1, 1 \leq y_i \leq d - 1$, and $f_i$ is one of N, E, W, and S, meaning north, east, west, and south, respectively. The position $(x, y)$ means $x$ distant from the west wall and $y$ distant from the south wall.

Output

Print the minimum number of clocks needed.

Sample Input 1

2 10 6
4 4 E
6 4 W

Sample Output 1

2

Sample Input 2

2 10 6
2 4 E
6 4 W

Sample Output 2

1

Sample Input 3

2 10 6
3 2 S
6 4 W

Sample Output 3

1

Sample Input 4

6 10 6
1 5 N
7 1 N
8 2 E
9 1 S
4 4 S
3 3 W

Sample Output 4

3

Sample Input 5

4 10 6
4 3 W
2 4 N
4 4 W
3 3 S

Sample Output 5

2

Sample Input 6

4 100000 40000
25000 25000 S
20000 30000 S
75000 25000 S
80000 30000 S

Sample Output 6

1

Solution in JAVA (judge verdict: Wrong Answer)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;


public class Main {

    public static void main(String[] args) throws Exception {
        new Main().solve();
    }

    int w, h;

    int flatten(int x, int y) {
        // 1?¬????????±?????????????????????????ccw?????§
//        System.out.println("(" + x + "," + y + ")");
        // (0,0) -> 0
        // (0,h) -> h
        // (w,h) -> h+w
        // (w,0) -> 2h+w
        // (0,0) -> 2(h+w)
        if (x == 0) {
            return y;
        }
        else if (y == h) {
            return h + x;
        }
        else if (x == w) {
            return h + w + (h - y);
        }
        else if (y == 0) {
            return 2 * h + w + (w - x);
        }
        else throw new IllegalArgumentException();
    }

    boolean inRange(int min, int v, int max) {
        if (min > max) {
            // ??????????????????
            return min <= v || v <= max;
        }
        else {
            return min <= v && v <= max;
        }
    }

    boolean inRange(int v, int[] range) {
        return inRange(range[0], v, range[1]);
    }

    private void solve() throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        w = sc.nextInt();
        h = sc.nextInt();

        int[][] ranges = new int[n][2];  // start, end

        for (int i = 0; i < n; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            char d = sc.next().charAt(0);
            if (d == 'N') {
                int dl = Math.min(x, y);
                int dr = Math.min(w - x, y);
                ranges[i][0] = flatten(x + dr, y - dr);
                ranges[i][1] = flatten(x - dl, y - dl);
            }
            else if (d == 'W') {
                int dt = Math.min(x, y);
                int db = Math.min(x, h - y);
                ranges[i][0] = flatten(x - dt, y - dt);
                ranges[i][1] = flatten(x - db, y + db);
            }
            else if (d == 'S') {
                int dl = Math.min(x, h - y);
                int dr = Math.min(w - x, h - y);
                ranges[i][0] = flatten(x - dl, y + dl);
                ranges[i][1] = flatten(x + dr, y + dr);
            }
            else if (d == 'E') {
                int dt = Math.min(w - x, y);
                int db = Math.min(w - x, h - y);
                ranges[i][0] = flatten(x + db, y + db);
                ranges[i][1] = flatten(x + dt, y - dt);
            }
        }

        Arrays.sort(ranges, new Comparator<int[]>() {

            @Override
            public int compare(int[] o1, int[] o2) {
                // TODO Auto-generated method stub
                return o1[1] - o2[1];
            }

        });

        // debug show
//        for (int i = 0; i < n; i++) {
//            System.out.println(i + ": [" + ranges[i][0] + ", " + ranges[i][1] + "]");
//        }
        // ??????????????????

        // n=1000?????????2??????????????????????????????????¬????????±???????????????????????????????????????§????????¨???????¬??????????

        TreeSet<Integer> changingPoints = new TreeSet<Integer>();
        for (int i = 0; i < n; i++) {
            // changingPoints.add(ranges[i][0]);
            changingPoints.add(ranges[i][1]);
        }
        int[] candidates = new int[changingPoints.size()];
        {
            int i = 0;
            for (int c : changingPoints) {
                candidates[i++] = c;
            }
        }

        int ans = 10000000;
        for (int firstClock : candidates) {
            ArrayList<int[]> curRs = new ArrayList<int[]>();
            int firstPosIdx = -1;
            for (int i = 0; i < n; i++) {
                if (!inRange(firstClock, ranges[i])) {
                    curRs.add(ranges[i]);
                }
                else if (firstPosIdx == -1) {
                    firstPosIdx = curRs.size();
                }
            }
            Collections.rotate(curRs, curRs.size() - firstPosIdx);  // ??????????????????????????????????????£?????????
//            System.out.print("curRs: [");
//            for (int[] range : curRs) {
//                System.out.print(Arrays.toString(range) + ",");
//            }
//            System.out.println("]");
            int lastClock = -1;
            int numClock = 1;
            for (int[] range : curRs) {
                if (lastClock == -1 || !inRange(lastClock, range)) {
                    numClock++;
                    lastClock = range[1];
                }
            }
//            System.out.println("firstClock: " + firstClock + ", ans: " + numClock);
            ans = Math.min(ans, numClock);
        }

        System.out.println(ans);
    }
}