Question

我一直在研究这个HackerRank问题已经有一段时间了，我似乎无法理解为什么我的代码会因大输入大小而超时。我已经将邻接列表实现为哈希映射以缩短时间，并且已经为我的DFS使用堆栈，这是优化它的运行时的标准。我的基本策略是使用DFS删除一组连接节点，并继续这样做，直到没有剩余（我的DFS在到达时删除节点），问题是每个图形通常有~80,000个断开连接的部分后，我取出没有邻居的单个节点（所以DFS被称为80,000次）。这里有什么特别好的策略吗？

  static int numDisconnected(HashMap<Integer, List<Integer>> adj)  {
    int result = 0;
    List<Integer> iter = new ArrayList<>(adj.keySet());
    for (int k : iter) {
      if (adj.get(k).size() == 0)  {
        adj.remove(k);
        result++;
      }
    }
    HashMap<Integer,Boolean> explored = new HashMap<>();
    for (int i : adj.keySet())  {
      explored.put(i,false);
    }
    while (!adj.keySet().isEmpty())  {
      result++;
      depthFirstSearch(adj,explored);
    }
    return result;
  }

作为参考，我的代码需要大约1.5秒才能在我的机器上运行~2MB文件输入。

Answer 1

通常，您正在做的是关闭，HashMap<Integer, List<Integer>>是此任务的良好数据结构。但是，您要通过保留explored列表并从numDisconnected和depthFirstSearch中的邻接地图中删除（在您早期版本的问题中）来执行冗余工作。这些中的任何一个都足以实现深度优先搜索。

我调整了你的算法，没有从adj中移除，将explored更改为boolean []并使用它来探索断开连接的组件，并找到下一个节点从组件完成时启动DFS。 / p>

它通过了，不需要删除未连接节点的预处理步骤。

（抱歉代言而不是发布代码，但我宁愿不破坏它）

Answer 2

从原始代码开始（在此问题的第一个版本中），我将这些HashMap替换为ArrayList s，使用HashSet替换为explored，内联depthFirstSearch（只是为了简单而不是性能），并且摆脱了一些感觉像过早优化的步骤（删除没有邻居的节点，在主循环中提前返回）。

这会传递Roads and Libraries challenge on HackerRank中的所有测试：

import java.io.*;
import java.util.*;

public class Solution {
    static long cost(long cLib, long cRoad, ArrayList<List<Integer>> g, int gSize)  {
        if (cLib <= cRoad)  {
            return cLib * (long)gSize;
        }
        int discon = numDisconnected(g);
        return (cRoad * (gSize - discon)) + (cLib * discon);
    }

    static int numDisconnected(ArrayList<List<Integer>> adj)  {
        int result = 0;
        HashSet<Integer> explored = new HashSet<>();
        int length = adj.size();
        for (int i = 0; i < length; i++) {
            if (!explored.contains(i)) {
                Stack<Integer> stack = new Stack<>();
                stack.push(i);
                while (!stack.empty()) {
                    int curr = stack.pop();
                    explored.add(curr);
                    for (int neighbor : adj.get(curr)) {
                        if (!explored.contains(neighbor)) {
                            stack.push(neighbor);
                        }
                    }
                }

                result += 1;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int q = in.nextInt();
        for(int a0 = 0; a0 < q; a0++){
            int nCities = in.nextInt();
            ArrayList<List<Integer>> adj = new ArrayList<List<Integer>>(nCities);
            for (int i = 0; i < nCities; i++) {
                adj.add(new ArrayList<Integer>());
            }
            int nRoads = in.nextInt();
            long cLib = in.nextLong();
            long cRoad = in.nextLong();
            for (int i = 0; i < nRoads; i++) {
                int city_1 = in.nextInt() - 1;
                int city_2 = in.nextInt() - 1;
                adj.get(city_1).add(city_2);
                adj.get(city_2).add(city_1);
            }
            System.out.println(cost(cLib, cRoad, adj, nCities));
        }
    }
}

HackerRack上的道路和图书馆超时

2 个答案: