Question

我只能想到一种蛮力方法来计算每个可能的gcd并从源到目标运行bfs来检查是否存在路径。

但是上述方法在5个测试案例中给出了TLE。任何人都可以提供更有效的方法吗？

Answer 1

这是我将要使用的图形结构的快速实现：

class GCDGraph {

    private Map<Integer, Set<Integer>> adj = new HashMap<>();

    public GCDGraph(int g, int[] srcCities, int[] dstCities){
        int n = srcCities.length;
        for(int i=0;i<n;i++){
            adj.put(i, new HashSet<>());
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                int gtmp = gcd(srcCities[i], dstCities[j]);
                if(gtmp > g){
                    adj.get(i).add(j);
                    adj.get(j).add(i);
                }
            }
            // we could add the connection i -> i (assuming srcCities[i] > g)
            // but that would not help us find a path, as it introduces a cycle
        }
    }

    private int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }

    public Set<Integer> adjacentVertices(int vertex){ return adj.get(vertex); }

    public int size(){ return adj.size(); }

    public boolean isEmpty(){ return size() == 0; }

    public boolean hasPath(int src, int dst){
        return buildPath(src, dst, new HashSet<>());
    }

    private boolean buildPath(int src, int dst, Set<Integer> tmp){
        if(src == dst){
            return true;
        } else {
            for(int nextVertex : adjacentVertices(src)){
                if(tmp.contains(nextVertex))
                    continue;
                tmp.add(nextVertex);
                if(buildPath(nextVertex, dst, tmp))
                    return true;
                tmp.remove(nextVertex);
            }
        }
        return false;
    }
}

它将邻接关系显式存储为Map（允许快速查找）。
它具有一些实用方法（大小，isEmpty）。
仅在构建GCD时查找GCD，并且每个x / y对仅查找一次。
并且它使用递归来执行BFS，并尽快退出。

城市之间是否存在路径

1 个答案: