@Override public Vertex<V> opposite(Vertex<V> v, Edge<E, V> e) { Vertex<V> vt; if (e.getSource().equals(v)) vt = (Vertex<V>) e.getDestination(); else if (e.getDestination().equals(v)) vt = (Vertex<V>) e.getSource(); else vt = null; return vt; }
public Node whatNodeIGetTo(Node from, Transition with) { for (Edge e : myGraph.edgeSet()) { if (e.getSource().equals(from) && e.getTransition().equals(with)) { return e.getDest(); } } return null; }
private Graph buildGraph(List<Edge> edges) { Graph toReturn = new Graph(); for (Edge e : edges) { toReturn.addNode(e.getSource()); toReturn.addNode(e.getDest()); toReturn.addEdge(e); } return toReturn; }
public double weight() { double result = 0.0; for (Edge e : mst) { result += e.weight(); } return result; }
@Override public Edge<E, V> insertEdge(Vertex<V> v, Vertex<V> w, E ele) throws Exception { @SuppressWarnings("unchecked") Position<PositionAwareType<E>> pos = edges.addPos(ele, (Class<? extends PositionAwareType<E>>) Edge.class); @SuppressWarnings("unchecked") Edge<E, V> eg = (Edge<E, V>) pos.element(); eg.setSource(v); eg.setDestination(w); return eg; }
/** * Test whether vertex b is adjacent to vertex a (i.e. a -> b) in a directed graph. Assumes that * we do not have negative cost edges in the graph. * * @param a one vertex * @param b another vertex * @return cost of edge if there is a directed edge from a to b in the graph, return -1 otherwise. * @throws IllegalArgumentException if a or b do not exist. */ @Override public int edgeCost(Vertex a, Vertex b) { if (a == null || b == null || !totalVertices.contains(a) || !totalVertices.contains(b)) { throw new IllegalArgumentException(); } for (Edge edge : adj.get(a)) { if (edge.getDestination().equals(b)) { return edge.getWeight(); } } return -1; }
@SuppressWarnings("unchecked") public String printEdges() { String s = ""; Edge<E, V> eg = (Edge<E, V>) edges.getHeader(); while (eg != null) { s += eg.toString() + " "; try { eg = (Edge<E, V>) edges.next((Pointer<E>) eg.getPosition()).element(); } catch (Exception exc) { eg = null; } } return s; }
@SuppressWarnings("unchecked") @Override public List<Edge<E, V>> list_edges() { List<Edge<E, V>> coll = new ArrayList<Edge<E, V>>(); Edge<E, V> head_edg = (Edge<E, V>) edges.getHeader(); while (head_edg != null) { coll.add(head_edg); try { head_edg = (Edge<E, V>) edges.next((Pointer<E>) head_edg.getPosition()).element(); } catch (Exception exc) { head_edg = null; } } return coll; }
/** * Return a collection of vertices adjacent to a given vertex v. i.e., the set of all vertices w * where edges v -> w exist in the graph. Return an empty collection if there are no adjacent * vertices. * * @param v one of the vertices in the graph * @return an iterable collection of vertices adjacent to v in the graph * @throws IllegalArgumentException if v does not exist. */ @Override public Collection<Vertex> adjacentVertices(Vertex v) { if (v == null || !totalVertices.contains(v)) { throw new IllegalArgumentException(); } List<Vertex> destiVertex = new ArrayList<Vertex>(); // Returns the edge to which the specified key is mapped, or null if // this map contains no mapping for the key.Then add the edge to the // ArrayList for (Edge e : adj.get(v)) { destiVertex.add(e.getDestination()); } return destiVertex; }
@SuppressWarnings("unchecked") @Override public Iterator<Edge<E, V>> edges(String type) { List<Edge<E, V>> coll = new ArrayList<Edge<E, V>>(); Edge<E, V> head_edg = (Edge<E, V>) edges.getHeader(); while (head_edg != null) { if (head_edg.getType().equals(type)) coll.add(head_edg); try { head_edg = (Edge<E, V>) edges.next((Pointer<E>) head_edg.getPosition()).element(); } catch (Exception exc) { head_edg = null; } } return coll.iterator(); }
@SuppressWarnings("unchecked") public String printEdges(String type) { String s = ""; Edge<E, V> eg = (Edge<E, V>) edges.getHeader(); while (eg != null) { if (eg.getType().equals(type)) s += eg.getSource().getInfo() + " -> " + eg.getDestination().getInfo() + "\n"; try { eg = (Edge<E, V>) edges.next((Pointer<E>) eg.getPosition()).element(); } catch (Exception exc) { eg = null; } } return s; }
/* * Methode to calculate a weight for a way to the start point , it can be * one edge or a couple of edges */ private static int calculateWeightOfWay(Vertex firstVertex, Vertex secondVertex) { int currentWeight = (Integer) verticesMap.get(firstVertex.getId()).get(1); ArrayList<Edge<Vertex>> edgesOfFirstVertex = (ArrayList<Edge<Vertex>>) graph.getIncidentEdges(firstVertex.getId()); for (Edge<Vertex> e : edgesOfFirstVertex) { if (e.getVertexB().getId() == secondVertex.getId()) { int edgeWeightBetweenFirstandSecond = e.getWeight(); return edgeWeightBetweenFirstandSecond + currentWeight; } } System.out.println("no edge weight found"); return 0; }
@SuppressWarnings("unchecked") @Override public Iterator<Vertex<V>> adjacentVertices(Vertex<V> v) { List<Vertex<V>> coll = new ArrayList<Vertex<V>>(); Edge<E, V> head_edg = (Edge<E, V>) edges.getHeader(); while (head_edg != null) { if (head_edg.getSource().equals(v)) coll.add((Vertex<V>) head_edg.getDestination()); try { head_edg = (Edge<E, V>) edges.next((Pointer<E>) head_edg.getPosition()).element(); } catch (Exception exc) { head_edg = null; } } return coll.iterator(); }
/** * Perform a traversal of G over all vertices reachable from V. ORDER determines the ordering in * which the successors to the set of traversed vertices are visited. */ public void traverse(Graph<VLabel, ELabel> G, Vertex<VLabel> v, Comparator<VLabel> order) { _graph = G; if (_fringe.isEmpty()) { _fringe.add(v); } _order = order; while (!_fringe.isEmpty()) { Collections.sort(_fringe, new VertexComparator()); Vertex<VLabel> vert = _fringe.get(0); if (!_markedVertices.contains(vert)) { _markedVertices.add(vert); try { _finalEdge = null; _finalVertex = vert; this.visit(vert); } catch (StopException e) { return; } catch (RejectException e) { continue; } Iterator<Edge<VLabel, ELabel>> iter = G.outEdges(vert); while (iter.hasNext()) { Edge<VLabel, ELabel> nextEdge = iter.next(); if (!_markedEdges.contains(nextEdge)) { _markedEdges.add(nextEdge); try { _finalVertex = null; _finalEdge = nextEdge; this.preVisit(nextEdge, vert); } catch (StopException e) { return; } catch (RejectException e) { continue; } if (!_fringe.contains(nextEdge.getV1())) { _fringe.add(nextEdge.getV1()); } } } } _fringe.remove(0); } }
public List<Graph> getAllNodeCoverage() { Node initial = getInitialState(); Set<Node> toVisit = new HashSet<>(nodes); toVisit.remove(initial); Set<Node> left = new HashSet<>(nodes); left.remove(initial); List<Graph> toReturn = new ArrayList<>(); for (Node visiting : toVisit) { if (left.contains(visiting)) { DijkstraShortestPath<Node, Edge> pathFinder = new DijkstraShortestPath<>(myGraph, initial, visiting); List<Edge> path = pathFinder.getPathEdgeList(); for (Edge e : path) { left.remove(e.getDest()); } toReturn.add(buildGraph(path)); } } return toReturn; }
/** * performs the Dijkstra algorithm * * @param graph a graph, in which the Dijkstra will be performed * @param queue a queue of vertices to help perform Dijkstra * @param startVertexID a start vertices id * @param destinationVertexID an end vertices id */ private static void performeDijkstra( Graph<Vertex, Edge<Vertex>> graph, ArrayList<Vertex> queue, int startVertexID, int destinationVertexID) { while (queue.size() != 0) { int lowest = 0; for (int i = 0; i < queue.size(); i++) { if (queue.get(i).getDistance() < queue.get(lowest).getDistance()) { lowest = i; } } Vertex lowestElementInQueue = queue.get(lowest); // stop the loop if the destination is reached if (lowestElementInQueue.getId() == destinationVertexID) break; queue.remove(lowestElementInQueue); Collection<Edge<Vertex>> edgesOfFirstVertex = graph.getIncidentEdges(lowestElementInQueue); if (edgesOfFirstVertex.size() != 0) { for (Edge<Vertex> edge : edgesOfFirstVertex) { Vertex neighbour = edge.getVertexB(); int weightOfEdge = edge.getWeight(); if (weightOfEdge < 0) { throw new IllegalArgumentException( "one edge of " + lowestElementInQueue.getId() + " is negative"); } relax(lowestElementInQueue, neighbour, weightOfEdge); } } } ResultsDisplay.printResults(graph); ResultsDisplay.printTheShortestWay(graph, startVertexID, destinationVertexID); }
public KruskalMST(EdgeWeightedGraph g) { mst = new Queue<Edge>(); MinPQ<Edge> pq = new MinPQ<Edge>(); for (Edge e : g.edges()) { pq.insert(e); } UnionFind uf = new UnionFind(g.vertices()); while (!pq.isEmpty() && mst.size() < g.vertices() - 1) { Edge e = pq.delMin(); int v = e.either(), w = e.other(v); if (uf.connected(v, w)) continue; // -- would form a cycle uf.union(v, w); mst.enqueue(e); } }
/** * Creates a MyGraph object with the given collection of vertices and the given collection of * edges. * * @param v a collection of the vertices in this graph * @param e a collection of the edges in this graph */ public MyGraph(Collection<Vertex> v, Collection<Edge> e) { // collection passed in should not be null if (v == null || e == null) { throw new IllegalArgumentException(); } adj = new HashMap<Vertex, ArrayList<Edge>>(); totalEdges = new ArrayList<Edge>(); totalVertices = new ArrayList<Vertex>(); checkExcepction(v, e); // loop through a collection // for (iterable_type iterable_element : collection) // Add edges and vertex to the map for (Edge edge : e) { if (!totalEdges.contains(edge)) { totalEdges.add(edge); } // if this vertex is not in key groups of the HashMap, add it to the group if (!adj.containsKey(edge.getSource())) { adj.put(edge.getSource(), new ArrayList<Edge>()); } // add edge to the ArrayList, which is the "value" in key-value pairs in HashMap, adj. adj.get(edge.getSource()).add(edge); } for (Vertex vertex : v) { if (!totalVertices.contains(vertex)) { totalVertices.add(vertex); } if (!adj.containsKey( vertex)) { // add this vertex as a key in adj even if there might not be edge extending // from it, // namely even if we end up with empty ArrayList as value of this key adj.put(vertex, new ArrayList<Edge>()); } } }
public List<Graph> getAllEdgeCoverage() { List<Edge> toVisit = new ArrayList<>(myGraph.edgeSet()); List<Edge> left = new ArrayList<>(myGraph.edgeSet()); List<Graph> toReturn = new ArrayList<>(); for (Edge e : toVisit) { if (left.contains(e)) { if (getInitialState().equals(e.getSource())) { List<Edge> toAdd = new ArrayList<>(); toAdd.add(e); toReturn.add(buildGraph(toAdd)); } else { List<Edge> path = BellmanFordShortestPath.findPathBetween(myGraph, getInitialState(), e.getSource()); path.add(e); left.remove(e); left.removeAll(path); toReturn.add(buildGraph(path)); } } } return toReturn; }
public boolean isLegalMapping(Edge eQ, Edge eC) { if (!notMapped(eC)) { return false; } if (!eQ.getTail().getBpmnType().equals(eC.getTail().getBpmnType()) && !eQ.getHead().getBpmnType().equals(eC.getHead().getBpmnType())) { return false; } if (!areMapped(eQ.getTail(), eC.getTail()) && !areMapped(eQ.getHead(), eC.getHead())) { // System.out.println("Not Mapped: ID-Query(tail): " + eQ.getTail().getId() + " ID-Case(tail): // " + eC.getTail().getId()); // System.out.println("Not Mapped: ID-Query(head): " + eQ.getHead().getId() + " ID-Case(head): // " + eC.getHead().getId()); return false; } return true; }
@SuppressWarnings("unchecked") @Override public void reverseDirection() { Edge<E, V> h = (Edge<E, V>) edges.getHeader(); while (h != null) { Vertex<V> temp = h.getSource(); h.setSource(h.getDestination()); h.setDestination(temp); try { h = (Edge<E, V>) edges.next((Pointer<E>) h.getPosition()).element(); } catch (Exception exc) { h = null; } } }
@SuppressWarnings("unchecked") @Override public boolean areAdjacent(Vertex<V> v, Vertex<V> w) { boolean b = false; Edge<E, V> eg = (Edge<E, V>) edges.getHeader(); while (eg != null && !b) { if ((eg.getDestination().equals(v) || eg.getSource().equals(v)) && (eg.getDestination().equals(w) || eg.getSource().equals(w))) b = true; try { eg = (Edge<E, V>) edges.next((Pointer<E>) eg.getPosition()).element(); } catch (Exception exc) { eg = null; } } return b; }
@SuppressWarnings("unchecked") @Override public void removeEdge(Edge<E, V> e) throws Exception { edges.removePos((Position<PositionAwareType<E>>) e.getPosition()); }
/** * Returns the shortest path from a to b in the graph, or null if there is no such path. Assumes * all edge weights are nonnegative. Uses Dijkstra's algorithm. * * @param a the starting vertex * @param b the destination vertex * @return a Path where the vertices indicate the path from a to b in order and contains a (first) * and b (last) and the cost is the cost of the path. Returns null if b is not reachable from * a. * @throws IllegalArgumentException if a or b does not exist. */ public Path shortestPath(Vertex a, Vertex b) { List<Vertex> vertexList = new ArrayList<Vertex>(); VertexComparator vcp = new VertexComparator(); PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>(10, vcp); // queue for unknow vertex // If the start and end vertex are equal // return a path containing one vertex and a cost of 0. if (a.equals(b)) { vertexList.add(a); return new Path(vertexList, 0); } // if the start and end vertex are not equal: // if there is no path starting from a, return null if (!adj.containsKey(a)) { return null; } // for (Vertex v : this.vertices() ) { // System.out.println(v.known); // } // initialize before searching path for (Vertex v : adj.keySet()) { // variables in adj.keySet() are actually pointers pointing to different memory with those in // this.vertices() // what we need is actually to change those in memory pointed by this.vertices() // have no idea why this.vertices.get() method did not work // thus I have to implement as below Vertex vn = v; // actually this is a bad initialization for (Vertex vi : this.vertices()) { if (vi.equals(v)) { vn = vi; } } vn.known = false; // set all vertex distance to infinity vn.distance = Integer.MAX_VALUE; // vn.distance = 99999; vertexQueue.add(vn); } // System.exit(1); // Set source vertex distance to 0 for (Vertex vn : this.vertices()) { if (vn.equals(a)) { vertexQueue.remove(vn); vn.distance = 0; vn.previous = vn; // update vn in vertexQueue vertexQueue.add(vn); } } // a.distance = 0; // a.previous = a; // vertexQueue.remove(a); // vertexList.add(a); Vertex end = b; for (Vertex vn : this.vertices()) { if (vn.equals(b)) { end = vn; } } // for (Vertex v : this.vertices() ) { // System.out.println(v.distance); // } System.out.println("start searching..."); // while ( (!vertexQueue.isEmpty()) && (end.known == false) ) { //while there are still unknow // vertex and vertex b is unknown while ((!vertexQueue .isEmpty())) { // while there are still unknow vertex and vertex b is unknown // System.out.println("elements in vertexQueue at beginning:"); // for (Vertex v : vertexQueue ) { // System.out.println(v.getLabel()); // System.out.println("distance: " + v.distance); // } Vertex nt = vertexQueue.poll(); // unknown node with smallest distance // System.out.println("marked " + nt + " as known."); // System.out.println("its current distance: " + nt.distance); nt.known = true; for (Edge e : adj.get(nt)) { // search for vertex with the same name as e.getDestination() in this.vertices() Vertex en = e.getDestination(); for (Vertex vn : this.vertices()) { if (vn.equals(e.getDestination())) { en = vn; } } if (!en.known) { if ((nt.distance + e.getWeight()) < en.distance) { // update en in vertexQueue vertexQueue.remove(en); en.distance = nt.distance + e.getWeight(); en.previous = nt; vertexQueue.add(en); } } } } System.out.println("finished computing shortest path."); // for (Vertex v : this.vertices() ) { // System.out.println(v.distance); // } // traverse to get path from a to b Vertex tmp = end; while (!tmp.equals(a)) { vertexList.add(0, tmp); // may need a heap here? tmp = tmp.previous; } vertexList.add(0, a); return new Path(vertexList, end.distance); // TODO: after searching for all possible path, return null if there is no path from a to b }
private void checkExcepction(Collection<Vertex> v, Collection<Edge> e) { for (Edge edge : e) { // No edge from or to vertex labeled A if there is no vertex with // label A if (!v.contains(edge.getSource()) || !v.contains(edge.getDestination())) { throw new IllegalArgumentException(); } // Edge weights should not be negative if (edge.getWeight() < 0) { throw new IllegalArgumentException(); } // Collection of edges should not has the same directed edge more // than once // with a different weight for (Edge checkEdges : e) { if (checkEdges.getSource().equals(edge.getSource()) && checkEdges.getDestination().equals(edge.getDestination()) && checkEdges.getWeight() != edge.getWeight()) { throw new IllegalArgumentException(); } } } }
public void addEdge(Edge toAdd) { myGraph.addEdge(toAdd.getSource(), toAdd.getDest(), toAdd); }