import java.util.*;

/**
* A representation of a graph. Assumes that we do not have negative cost edges
* in the graph.
*/
public class MyGraph implements Graph {
// you will need some private fields to represent the graph
// you are also likely to want some private helper methods

// YOUR CODE HERE
private HashMap<String, Vertex> vs;
private HashMap<String, Edge> es;

/**
* 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
* @throws java.lang.Exception
*/
public MyGraph(Collection<Vertex> v, Collection<Edge> e) throws Exception {

   // YOUR CODE HERE
   vs = new HashMap<>();
   es = new HashMap<>();

   String key;

   for (Vertex vertex : v) {
         key = vertex.getLabel();
         if (vs.containsKey(key) == false) {
            vs.put(key, vertex);
         }
   }

   Vertex v1;
   Vertex v2;
   Edge ed;

   for (Edge edge : e) {
         v1 = edge.getSource();
         v2 = edge.getDestination();
         VertexExistenceTest("Source vertex", v1.getLabel());
         VertexExistenceTest("Destination vertex", v2.getLabel());
         if (edge.getWeight() < 0) {
            throw new Exception("Edge weights should not be negative");
         }
         key = v1.getLabel() + "-" + v2.getLabel();
         ed = es.get(key);
         /* Do throw an exception if the collection of edges
            has the same directed edge more than once with a
            different weight
            Do not throw an exception if an edge appears
            redundantly with the same weight;
            just ignore the redundant edge information.
         */
         if (ed == null) {
            es.put(key, edge);
         } else if (ed.getWeight() != edge.getWeight()) {
            es.put(key, edge);
         }
   }
}

private void VertexExistenceTest(String name, String key) throws Exception {
   if (vs.containsKey(key) == false) {
         throw new Exception(name + " "
               + key + " is not found in the colletion of vettices");
   }
}

/**
* Return the collection of vertices of this graph
*
* @return the vertices as a collection (which is anything iterable)
*/
public Collection<Vertex> vertices() {

   // YOUR CODE HERE
   HashSet<Vertex> v = new HashSet<>();

   for (Map.Entry<String, Vertex> entry : vs.entrySet()) {
         v.add(entry.getValue());
   }
   return v;
}

/**
* Return the collection of edges of this graph
*
* @return the edges as a collection (which is anything iterable)
*/
public Collection<Edge> edges() {

   // YOUR CODE HERE
   HashSet<Edge> e = new HashSet<>();

   for (Map.Entry<String, Edge> entry : es.entrySet()) {
         e.add(entry.getValue());
   }
   return e;
}

/**
* 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.
*/
public Collection<Vertex> adjacentVertices(Vertex v) {

   // YOUR CODE HERE
   HashSet<Vertex> vt = new HashSet<>();
   if (v != null) {
         Edge e;
         for (Map.Entry<String, Edge> entry : es.entrySet()) {
            e = entry.getValue();
            // this condition is for undirected graph
            /* if (e.getSource().equals(v)) {
               vt.add(e.getDestination());
            } else if (e.getDestination().equals(v)) {
               vt.add(e.getSource());
            }*/

            // this condition is for directed graph
            if (e.getSource().equals(v)) {
               vt.add(e.getDestination());
            }
         }

   }
   return vt;
}

1. Define an interface that contains a single abstract method that...