C++ 障碍物计数问题解决方案：Java实现

import java.util.*;

public class ObstacleCount {

    // 定义一个常量 N 表示二维平面的最大行数和列数
    private static final int N = 60009;

    // 使用 ArrayList 存储每一行和每一列的障碍物位置
    private static List<Integer>[] Lx = new ArrayList[N];
    private static List<Integer>[] Ly = new ArrayList[N];

    // 定义变量 n、m 和 k 分别表示二维平面的行数、列数和障碍物的数量
    private static int n, m, k;

    // 检查点 (x, y) 是否为障碍物
    private static boolean isObstacle(int x, int y) {
        // 使用二分查找在 Lx[x] 中查找 y
        int l = 0, r = Lx[x].size() - 1, mid, ans = 0;
        while (l <= r) {
            mid = (l + r) >> 1;
            if (Lx[x].get(mid) <= y) {
                ans = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        // 如果 Lx[x][ans] + 1 == y，则说明 (x, y) 为障碍物
        return ans + 1 < Lx[x].size() && Lx[x].get(ans + 1) == y;
    }

    // 计算障碍物之间距离大于2的组合数量
    private static int solve() {
        int ret = 0;
        // 遍历每一行
        for (int i = 1; i < n; i++) {
            // 遍历该行中的所有障碍物
            for (int j = 1; j < Lx[i].size(); j++) {
                // 如果两个障碍物之间的距离大于2
                if (Lx[i].get(j) - Lx[i].get(j - 1) > 2) {
                    // 计数器加1
                    ret++;
                }
            }
        }
        // 遍历每一列
        for (int i = 1; i < m; i++) {
            // 遍历该列中的所有障碍物
            for (int j = 1; j < Ly[i].size(); j++) {
                // 如果两个障碍物之间的距离大于2
                if (Ly[i].get(j) - Ly[i].get(j - 1) > 2) {
                    // 计数器加1
                    ret++;
                }
                // 如果两个障碍物之间的距离等于2，且该障碍物下方存在障碍物
                if (Ly[i].get(j) - Ly[i].get(j - 1) == 2 && isObstacle(Ly[i].get(j - 1), i - 1)) {
                    // 计数器加1
                    ret++;
                }
            }
        }
        return ret;
    }

    public static void main(String[] args) {
        // 初始化 Lx 和 Ly 数组
        for (int i = 0; i < N; i++) {
            Lx[i] = new ArrayList<>();
            Ly[i] = new ArrayList<>();
        }
        // 读取输入
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        k = scanner.nextInt();
        int a, b;
        // 读取障碍物的位置信息
        for (int i = 0; i < k; i++) {
            a = scanner.nextInt();
            b = scanner.nextInt();
            Lx[a].add(b);
            Ly[b].add(a);
        }
        // 将障碍物位置信息添加到 Lx 和 Ly 中
        n++;
        m++;
        for (int i = 1; i < n; i++) {
            Lx[i].add(0);
            Lx[i].add(m);
        }
        for (int i = 1; i < m; i++) {
            Ly[i].add(0);
            Ly[i].add(n);
        }
        // 对 Lx 和 Ly 中的障碍物位置进行排序
        for (int i = 1; i < n; i++) {
            Collections.sort(Lx[i]);
        }
        for (int i = 1; i < m; i++) {
            Collections.sort(Ly[i]);
        }
        // 计算障碍物之间距离大于2的组合数量
        System.out.println(solve());
    }
}