[Daily Coding Problem 68] Count Pairs of attacking bishop pairs

This problem was asked by Google.

On our special chessboard, two bishops attack each other if they share the same diagonal. This includes bishops that have another bishop located between them, i.e. bishops can attack through pieces.

You are given N bishops, represented as (row, column) tuples on a M by M chessboard. Write a function to count the number of pairs of bishops that attack each other. The ordering of the pair doesn't matter: (1, 2) is considered the same as (2, 1).

For example, given M = 5 and the list of bishops:

• (0, 0)
• (1, 2)
• (2, 2)
• (4, 0)

The board would look like this:

[b 0 0 0 0]
[0 0 b 0 0]
[0 0 b 0 0]
[0 0 0 0 0]
[b 0 0 0 0]

You should return 2, since bishops 1 and 3 attack each other, as well as bishops 3 and 4.

 

The naive solution is to check each pair of all possible pairs. Its runtime is O(N^2). Can we make this any faster?

The bottle neck of the naive solution is that on a particular diagonal, if there are m bishops, then it takes m * (m - 1) / 2, which is O(m^2) time. It does not use the information that all of these bishops are in fact on the same diagonal already. A better solution is to go through each bishop and bucket them into each separate diagonal. For each diagonal with m bishops on it, there are m * (m - 1) / 2 attacking pairs. This reduces the runtime of getting all attacking pairs from one diagonal to O(m). 

Now we just need to find a good way of bucketing all bishops. We need a slope and a point to definitively specify a line in a 2D-coordinates. In this case, there can be only 2 slopes, +1 or -1.  And we can use the boundary coordinates of the chessboard to bucket each bishops.

For bishop (x, y),

1. when the slope is 1, if x > y, the boundary point is (x - y, y - y); else the boundary point is (x - x, y - x); so boundary point is (x - min(x, y), y - min(x, y)).

2. when the slope is -1, if x > y, the boundary point is (x - x, y + x); else the boundary point is (x - (M - y), y + (M -y)); so the boundary point is (x - min(x, M - y), y + min(x, M - y)).

We can use two maps of map save the diagonals buckets. We must use 2 separate maps, 1 for each slope because for each boundary point, there are 2 possilbe diagonals, one with slope 1, one with slope -1.

 

public class AttackingBishop {
    class Point {
        int x, y;
    }
    public int countAttackingBishopPairs(Point[] points, int M) {
        Map<Integer, Map<Integer, Integer>> posMap = new HashMap<>();
        Map<Integer, Map<Integer, Integer>> negMap = new HashMap<>();
        for(Point point : points) {
            int posBoundaryX = point.x - Math.min(point.x, point.y);
            int posBoundaryY = point.y - Math.min(point.x, point.y);
            int negBoundaryX = point.x - Math.min(point.x, M - point.y);
            int negBoundaryY = point.y + Math.min(point.x, M - point.y);

            if(!posMap.containsKey(posBoundaryX)) {
                posMap.put(posBoundaryX, new HashMap<>());
            }
            if(!posMap.get(posBoundaryX).containsKey(posBoundaryY)) {
                posMap.get(posBoundaryX).put(posBoundaryY, 0);
            }
            Map<Integer, Integer> map = posMap.get(posBoundaryX);
            map.put(posBoundaryY, map.get(posBoundaryY) + 1);

            if(!negMap.containsKey(negBoundaryX)) {
                negMap.put(negBoundaryX, new HashMap<>());
            }
            if(!negMap.get(negBoundaryX).containsKey(negBoundaryY)) {
                negMap.get(negBoundaryX).put(negBoundaryY, 0);
            }
            map = negMap.get(negBoundaryX);
            map.put(negBoundaryY, map.get(negBoundaryY) + 1);
        }
        int count = 0;
        for(Map<Integer, Integer> map : posMap.values()) {
            for(int c : map.values()) {
                count += c * (c - 1) / 2;
            }
        }
        for(Map<Integer, Integer> map : negMap.values()) {
            for(int c : map.values()) {
                count += c * (c - 1) / 2;
            }
        }
        return count;
    }
}

 

A more concise implementation is to customize your own key and only use a hash map.

public class AttackingBishop {
    class Point {
        int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int hashCode() {
            return 31 * x + 37 * y;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null || getClass() != obj.getClass()) {
                return false;
            }
            Point p = (Point) obj;
            if (x != p.x || y != p.y) {
                return false;
            }
            return true;
        }
    }

    public int countAttackingBishopPairs(Point[] points, int M) {
        Map<Point, Integer> posMap = new HashMap<>();
        Map<Point, Integer> negMap = new HashMap<>();
        for (Point point : points) {
            Point p1 = new Point(point.x - Math.min(point.x, point.y), point.y - Math.min(point.x, point.y));
            Point p2 = new Point(point.x - Math.min(point.x, M - point.y), point.y + Math.min(point.x, M - point.y));
            if (!posMap.containsKey(p1)) {
                posMap.put(p1, 1);
            } else {
                posMap.put(p1, posMap.get(p1) + 1);
            }
            if (!negMap.containsKey(p2)) {
                negMap.put(p2, 1);
            } else {
                negMap.put(p2, negMap.get(p2) + 1);
            }
        }
        int count = 0;
        for (int c : posMap.values()) {
            count += c * (c - 1) / 2;
        }
        for (int c : negMap.values()) {
            count += c * (c - 1) / 2;
        }
        return count;
    }
}