コード例 #1
0
  public static MultiKeyMap getEdges() {
    MultiKeyMap result = new MultiKeyMap();

    List<Station> stations = StationProviderStub.getStations();

    int counter = 1;
    for (Station station : stations) {
      for (Station neighbour : station.getIncidentStations()) {
        if (station.equals(neighbour)) {
          continue;
        }

        RouteEdge edge = new RouteEdge();
        edge.setId(counter++);
        edge.setDepartureStation(station);
        edge.setArrivalStation(neighbour);
        edge.setDuration(station.getId() + neighbour.getId());
        edge.setCost(station.getId() + neighbour.getId());

        result.put(station, neighbour, Collections.singletonList(edge));
      }
    }

    return result;
  }
コード例 #2
0
  /**
   * Returns the set of nodes reachable from the given set of initial nodes in the given graph
   * according to the criteria in the given legal pairs object.
   *
   * <p>A variable V is reachable from initialNodes iff for some variable X in initialNodes thers is
   * a path U [X, Y1, ..., V] such that legalPairs.isLegalFirstNode(X, Y1) and for each [H1, H2, H3]
   * as subpaths of U, legalPairs.isLegalPairs(H1, H2, H3).
   *
   * <p>The algorithm used is a variant of Algorithm 1 from Geiger, Verma, & Pearl (1990).
   *
   * @param initialNodes The nodes that reachability paths start from.
   * @param legalPairs Specifies initial edges (given initial nodes) and legal edge pairs.
   * @param c a set of vertices (intuitively, the set of variables to be conditioned on.
   * @param d a set of vertices (intuitively to be used in tests of legality, for example, the set
   *     of ancestors of c).
   * @param graph the graph with respect to which reachability is determined.
   */
  public static Set<Node> getReachableNodes(
      List<Node> initialNodes, LegalPairs legalPairs, List<Node> c, List<Node> d, Graph graph) {
    HashSet<Node> reachable = new HashSet<Node>();
    MultiKeyMap visited = new MultiKeyMap();
    List<ReachabilityEdge> nextEdges = new LinkedList<ReachabilityEdge>();

    for (Node x : initialNodes) {
      List<Node> adjX = graph.getAdjacentNodes(x);

      for (Node y : adjX) {
        if (legalPairs.isLegalFirstEdge(x, y)) {
          reachable.add(y);
          nextEdges.add(new ReachabilityEdge(x, y));
          visited.put(x, y, Boolean.TRUE);
        }
      }
    }

    while (nextEdges.size() > 0) {
      List<ReachabilityEdge> currEdges = nextEdges;
      nextEdges = new LinkedList<ReachabilityEdge>();

      for (ReachabilityEdge edge : currEdges) {
        Node x = edge.getFrom();
        Node y = edge.getTo();
        List<Node> adjY = graph.getAdjacentNodes(y);

        for (Node z : adjY) {
          if ((visited.get(y, z)) == Boolean.TRUE) {
            continue;
          }

          if (legalPairs.isLegalPair(x, y, z, c, d)) {
            reachable.add(z);
            nextEdges.add(new ReachabilityEdge(y, z));
            visited.put(y, z, Boolean.TRUE);
          }
        }
      }
    }

    return reachable;
  }