public void shortestPath(Integer sourceVertex, Integer destinationVertex) {
        final Map<Integer, Integer> cost = new HashMap<>();
        Map<Integer, Integer> parent = new HashMap<>();

        PriorityQueue<Integer> heap = new PriorityQueue<>(getAllVertex().size(), new Comparator<Integer>() {
            @Override
            public int compare(Integer p1, Integer p2) {
                return Integer.compare(cost.get(p1), cost.get(p2));
            }
        });

        heap.add(sourceVertex);
        cost.put(sourceVertex, 0);
        parent.put(sourceVertex, null);

        while(!heap.isEmpty()) {
            Integer p  = heap.remove();

            for(SimpleEdge e : getOutgoingEdges(p, false)) {
                int newCost = cost.get(p) + e.weight;
                if((!cost.containsKey(e.to) || newCost < cost.get(e.to))) {
                   cost.put(e.to, newCost);
                   parent.put(e.to, p);
                   heap.add(e.to);
                }

            }
        }

        if(parent.containsKey(destinationVertex)) {
            System.out.println(destinationVertex);
            while(true) {
                if(parent.get(destinationVertex) == null) {
                    break;
                }
                System.out.println(parent.get(destinationVertex));
                destinationVertex = parent.get(destinationVertex);
            }
        }

    }