Java 计算无向图中无序对的数量

可以找到问题的链接

问题陈述

Burger镇是一个由N个特殊路口和N个−1. 路径。在每对连接之间正好有一条最短路径 交叉点。连接点i位于（xi，yi）和 两个接合点i、j由出租车几何体定义

蒂姆最近雇了一辆出租车来当出租车司机。伊斯 这辆车很便宜，但有一个很大的缺陷。它只能驱动H 换料前，机组水平，V型机组垂直

如果客户希望从一个路口被带到另一个路口 j路口，那么这辆车只能开这条路线，iff 上的水平距离和垂直距离之和 该路径分别小于或等于H和V

此外，任何两个交叉点之间都有一条唯一的路径

现在他想把车还给卖家。 但他首先想知道这是否值得。这就是他想要的原因 知道无序对（i，j）的数量，以便 可以驾驶客户从i号交叉口到j号交叉口

约束条件

二,≤ N≤ 10^5

0≤ H、 五≤ 10^14

0≤ 席，一≤ 10^9

我已经用递归解决了这个问题。但是在一些测试用例中，我的代码超时了

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        long H = in.nextLong();
        long V = in.nextLong();
        List<Vertex> vertex = new ArrayList<>();

        for (int i=0; i < N; i++) {
            Vertex vx = new Vertex(in.nextLong(), in.nextLong());
            vertex.add(vx);
        }
        for (int i=0; i < N-1; i++) {
            int fromPath = in.nextInt()-1;
            int toPath = in.nextInt()-1;
            vertex.get(fromPath).neighbours.add(vertex.get(toPath));
            vertex.get(toPath).neighbours.add(vertex.get(fromPath));
        }

        long count = 0;

        for (int i=0; i < N; i++) {
            count += (N - findUnorderedPairs(vertex.get(i), null, 0, 0, H, V));
        }

        System.out.println(count/2);
        int temp = 0;

    }

    private static long findUnorderedPairs(Vertex vertex, Vertex previousVertex, long hor, long vert, long H, long V) {
        if (hor > H || vert > V) {
            return 0;
        }

        long result = 1;

        for (Vertex v : vertex.neighbours) {
                result += (v != previousVertex) ? findUnorderedPairs(v, vertex, hor + Math.abs(vertex.x - v.x), vert + Math.abs(vertex.y - v.y), H, V) : 0;

        }

        return result;
    }

    private static class Vertex {
        private long x;
        private long y;
        public ArrayList<Vertex> neighbours;

        public Vertex(long x, long y) {
            this.x = x;
            this.y = y;
            neighbours = new ArrayList<>();
        }
    }
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int N=in.nextInt（）；
长H=in.nextLong（）；
长V=in.nextLong（）；
列表顶点=新的ArrayList（）；
对于（int i=0；iH | | vert>V）{
返回0；
}
长期结果=1；
用于（顶点v：顶点.邻接点）{
结果+=（v！=上一个顶点）？查找未排序对（v，顶点，hor+Math.abs（顶点x-v.x），顶点+Math.abs（顶点y-v.y），H，v）：0；
}
返回结果；
}
私有静态类顶点{
私人长x；
私人长假；
公共阵列主义邻居；
公共顶点（长x、长y）{
这个.x=x；
这个。y=y；
邻居=新的ArrayList（）；
}
}
}

我也尝试过Dijkstras的实现，但也没有成功

任何关于如何实现更快解决方案的建议都将不胜感激。

这里是一个

O（n log^2 n）

解决方案（对于这个问题来说，它已经足够快了：我使用它成功地被接受了，但我不会在这里发布我的代码，因为我认为理解算法本身比查看其实现更有用）

让我们使用树的质心分解。您可以在此处阅读有关它的更多信息：

---

如何合并子树的解决方案？我们可以将每个点表示为一对

（x，y）

其中

x

和

y

是通过

x

和

y

轴从该点到当前根的距离。对于每个点，我们要计算

x1+x2尝试Kruskal算法的其他点的数量。描述相互矛盾。在第一段中说，“每对交叉点之间正好有一条最短路径。”后来，它说，“而且，任何两个交叉点之间都有一条唯一的路径。“那是哪一条呢？@JimMischel我看不出有任何矛盾，
在任何两个交叉点之间都有一条唯一的路径
意味着这是一棵连通的树，而这条唯一的路径也是最短的路径。@Phamtrong:你说得对。“只有一条最短路径”只是无关的信息。阅读它会给人留下这样的印象：这是某种优化问题（即找到最短路径）。谢谢你。今天晚些时候我会尝试一下这个想法：）