Please Edit FHgraph.java to implement these changes Update...

Please Edit FHgraph.java to implement these changes

Update dijkstra() method to receive an ArrayList of elements, which will be used to specify the elements to exclude from the shortest path. When iterating over the Partially Processed Vertices (PPV), filter out the requested elements from the shortest paths. need to modify how the algorithm determines the path by iterating through the PPV queue.

Update methods that depend on dijkstra() and pass the filtered list.

BaseballFileReader.java

package shortestPath;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class BaseballFileReader {
    private String city1;
    private String city2;
    private int miles;

    public String getCity1() {
        return city1;
    }

    public String getCity2() {
        return city2;
    }

    public int getMiles() {
        return miles;
    }

    private ArrayList<Connection> connections;

    public BaseballFileReader() {
        connections = new ArrayList<>();
    }

    public ArrayList<Connection> readFile(String fileName) {
        try {
            File file = new File(fileName);
            Scanner sc = new Scanner(file);

            // Read in each line from the file
            while (sc.hasNextLine()) {
                String line = sc.nextLine();

                // Split the line into its three
                // components
                // in the file you provide, the split is ',' not a space
                String[] parts = line.split(",");

                // Creates a Connection object
                // with the data from the line
                // use trim method to remove extra spaces
                String city1 = parts[0].trim();
                String city2 = parts[1].trim();
                int miles = Integer.parseInt(parts[2].trim());
                Connection c = new Connection(city1, city2, miles);

                // Add the Connection to the list
                connections.add(c);
            }
        } catch (FileNotFoundException e){
            System.out.println("File not found");
        }

        return connections;
    }
}

Connection.java

public class Connection
{
   // the name of the source city
   private String source;
   // the name of destination city
   private String destination;

   // the distance between cities
   private int distance;

   /**
    * Constructor takes name for source and name of destination.
    * The distance is the cost between them.
    * @param source   name of the source
    * @param dest name of the destination
    * @param dist the cost between source and dest
    */
   public Connection(String source, String dest, int dist)
   {  
      this.source = source;
      this.destination = dest;
      this.distance = dist;
   }


   /**
    * Source city
    * @return the city name
    */
   public String getSource()
   {  return source; }


   /**
    * Destination city
    * @return the city name
    */
   public String getDestination()
   {  return destination;    }     
   

   /**
    * Distance between source and destination city
    * @return int value of distance
    */
   public int getDistance()
   {  return distance;   }


   /**
    * Two connections are the same if the source and destinations have the same name.
    * @return true if same connection. Otherwise false.
    */
   @Override
   public boolean equals(Object other)
   {
      if (other instanceof Connection)
      {
         Connection otherConn = (Connection)other;
         if (otherConn.source.equals(this.source) &&
             otherConn.destination.equals(this.destination))
            return true;
      }
      return false;
   }

   /**
    * Returns a string representation with the item name and count.
    */
   public String toString()
   {
      return String.format("%s, %s, %d\n", source, destination, distance);
   }
}
 

FHGraph.java

package shortestPath;

import java.util.*;

// --- FHvertex class ------------------------------------------------------
class FHvertex<E>
{
    public static Stack<Integer> keyStack = new Stack<Integer>();
    public static final int KEY_ON_DATA = 0, KEY_ON_DIST = 1;
    public static int keyType = KEY_ON_DATA;
    public static final double INFINITY = Double.MAX_VALUE;

    public HashSet< Pair<FHvertex<E>, Double> > adjList
            = new HashSet< Pair<FHvertex<E>, Double> >();

    public E data;

    public double dist;
    public FHvertex<E> nextInPath;  // for client-specific info

    /**
     * Creates an object of type FHvertex with an initial
     * data value passed as argument,
     * the distance to source of interest set to INFINITY to indicate unknown,
     * and nextInPath to FHvertex as null to indicate unknown.
     * @param x  The object being represented.
     */
    public FHvertex( E x )
    {
        data = x;
        dist = INFINITY;
        nextInPath = null;
    }
    public FHvertex() { this(null); }

    public void addToAdjList(FHvertex<E> neighbor, double cost)
    {
        adjList.add( new Pair<FHvertex<E>, Double> (neighbor, cost) );
    }

    public void addToAdjList(FHvertex<E> neighbor, int cost)
    {
        addToAdjList( neighbor, (double)cost );
    }

    public boolean equals(Object rhs)
    {
        FHvertex<E> other = (FHvertex<E>)rhs;
        switch (keyType)
        {
            case KEY_ON_DIST:
                return (dist == other.dist);
            case KEY_ON_DATA:
                return (data.equals(other.data));
            default:
                return (data.equals(other.data));
        }
    }

    public int hashCode()
    {
        switch (keyType)
        {
            case KEY_ON_DIST:
                Double d = dist;
                return (d.hashCode());
            case KEY_ON_DATA:
                return (data.hashCode());
            default:
                return (data.hashCode());
        }
    }

    public void showAdjList()
    {
        Iterator< Pair<FHvertex<E>, Double> > iter ;
        Pair<FHvertex<E>, Double> pair;

        System.out.print( "Adj List for " + data + ": ");
        for (iter = adjList.iterator(); iter.hasNext(); )
        {
            pair = iter.next();
            System.out.print( pair.first.data + "("
                    + String.format("%3.1f", pair.second)
                    + ") " );
        }
        System.out.println();
    }

    public static boolean setKeyType( int whichType )
    {
        switch (whichType)
        {
            case KEY_ON_DATA:
            case KEY_ON_DIST:
                keyType = whichType;
                return true;
            default:
                return false;
        }
    }
    public static void pushKeyType() { keyStack.push(keyType); }
    public static void popKeyType() { keyType = keyStack.pop(); };
}

//--- FHedge class ------------------------------------------------------

class FHedge<E> implements Comparable< FHedge<E> >
{
    FHvertex<E> source, dest;
    double cost;

    FHedge( FHvertex<E> src, FHvertex<E> dst, Double cst)
    {
        source = src;
        dest = dst;
        cost = cst;
    }

    FHedge( FHvertex<E> src, FHvertex<E> dst, Integer cst)
    {
        this (src, dst, cst.doubleValue());
    }

    FHedge()
    {
        this(null, null, 1.);
    }

    public int compareTo( FHedge<E> rhs )
    {
        return (cost < rhs.cost? -1 : cost > rhs.cost? 1 : 0);
    }
}

public class FHgraph<E>
{
    // the graph data is all here --------------------------
    protected HashSet< FHvertex<E> > vertexSet;

    // public graph methods --------------------------------
    public FHgraph ()
    {
        vertexSet = new HashSet< FHvertex<E> >();
    }

    public FHgraph( FHedge<E>[] edges )
    {
        this();
        int k, numEdges;
        numEdges = edges.length;

        for (k = 0; k < numEdges; k++)
            addEdge( edges[k].source.data,
                    edges[k].dest.data,  edges[k].cost);
    }

    public void addEdge(E source, E dest, double cost)
    {
        FHvertex<E> src, dst;

        // put both source and dest into vertex list(s) if not already there
        src = addToVertexSet(source);
        dst = addToVertexSet(dest);

        // add dest to source's adjacency list
        src.addToAdjList(dst, cost);
    }

    public void addEdge(E source, E dest, int cost)
    {
        addEdge(source, dest, (double)cost);
    }

    // adds vertex with x in it, and always returns ref to it
    public FHvertex<E> addToVertexSet(E x)
    {
        FHvertex<E> retVal, vert;
        boolean successfulInsertion;
        Iterator< FHvertex<E> > iter;

        // save sort key for client
        FHvertex.pushKeyType();
        FHvertex.setKeyType(FHvertex.KEY_ON_DATA);

        // build and insert vertex into master list
        retVal = new FHvertex<E>(x);
        successfulInsertion = vertexSet.add(retVal);

        if ( successfulInsertion )
        {
            FHvertex.popKeyType();  // restore client sort key
            return retVal;
        }

        // the vertex was already in the set, so get its ref
        for (iter = vertexSet.iterator(); iter.hasNext(); )
        {
            vert = iter.next();
            if (vert.equals(retVal))
            {
                FHvertex.popKeyType();  // restore client sort key
                return vert;
            }
        }

        FHvertex.popKeyType();  // restore client sort key
        return null;   // should never happen
    }


    public void showAdjTable()
    {
        Iterator< FHvertex<E> > iter;

        System.out.println( "------------------------ ");
        for (iter = vertexSet.iterator(); iter.hasNext(); )
            (iter.next()).showAdjList();
        System.out.println();
    }

    public HashSet< FHvertex<E> > getVertSet()
    {
        return (HashSet< FHvertex<E> > )vertexSet.clone();
    }

    public void clear()
    {
        vertexSet.clear();
    }

    public void setGraph( ArrayList< FHedge<E> > edges )
    {
        int k, numEdges;
        numEdges = edges.size();

        clear();
        for (k = 0; k < numEdges; k++)
            addEdge( edges.get(k).source.data,
                    edges.get(k).dest.data,  edges.get(k).cost);
    }

    // algorithms
    public boolean dijkstra(E x)
    {
        FHvertex<E> w, s, v;
        Pair<FHvertex<E>, Double> edge;
        Iterator< FHvertex<E> > iter;
        Iterator< Pair<FHvertex<E>, Double> > edgeIter;
        Double costVW;
        Deque< FHvertex<E> > partiallyProcessedVerts
                = new LinkedList< FHvertex<E> >();

        s = getVertexWithThisData(x);
        if (s == null)
            return false;

        // initialize the vertex list and place the starting vert in p_p_v queue
        for (iter = vertexSet.iterator(); iter.hasNext(); )
            iter.next().dist = FHvertex.INFINITY;

        s.dist = 0;
        partiallyProcessedVerts.addLast(s);

        // outer dijkstra loop
        while( !partiallyProcessedVerts.isEmpty() )
        {
            v = partiallyProcessedVerts.removeFirst();

            // inner dijkstra loop: for each vert adj to v, lower its dist
            // to s if you can
            for (edgeIter = v.adjList.iterator(); edgeIter.hasNext(); )
            {
                edge = edgeIter.next();
                w = edge.first;
                costVW = edge.second;
                if ( v.dist + costVW < w.dist )
                {
                    w.dist = v.dist + costVW;
                    w.nextInPath = v;

                    // w now has improved distance, so add w to PPV queue
                    partiallyProcessedVerts.addLast(w);
                }
            }
        }
        return true;
    }


    // applies dijkstra, print path - could skip dijkstra()
    public boolean showShortestPath(E x1, E x2)
    {
        FHvertex<E> start, stop, vert;
        Stack< FHvertex<E> > pathStack = new Stack< FHvertex<E> >();

        start = getVertexWithThisData(x1);
        stop = getVertexWithThisData(x2);
        if (start == null || stop == null)
            return false;

        // perhaps add argument opting to skip if pre-computed
        dijkstra(x1);

        if (stop.dist == FHvertex.INFINITY)
        {
            System.out.println("No path exists.");
            return false;
        }

        for (vert = stop; vert != start; vert = vert.nextInPath)
            pathStack.push(vert);
        pathStack.push(vert);

        System.out.println( "Cost of shortest path from " + x1
                + " to " + x2 + ": " + stop.dist );
        while (true)
        {
            vert = pathStack.pop();
            if ( pathStack.empty() )
            {
                System.out.println( vert.data );
                break;
            }
            System.out.print( vert.data + " -> ");
        }
        return true;
    }

    // applies dijkstra, prints distances - could skip dijkstra()
    public boolean showDistancesTo(E x)
    {

        Iterator< FHvertex<E> > iter;
        FHvertex<E> vert;

        if (!dijkstra(x))
            return false;

        for (iter = vertexSet.iterator(); iter.hasNext(); )
        {
            vert = iter.next();
            System.out.println( vert.data + " " + vert.dist);
        }
        System.out.println();
        return true;
    }

    protected FHvertex<E> getVertexWithThisData(E x)
    {
        FHvertex<E> searchVert, vert;
        Iterator< FHvertex<E> > iter;

        // save sort key for client
        FHvertex.pushKeyType();
        FHvertex.setKeyType(FHvertex.KEY_ON_DATA);

        // build vertex with data = x for the search
        searchVert = new FHvertex<E>(x);


        // the vertex was already in the set, so get its ref
        for (iter = vertexSet.iterator(); iter.hasNext(); )
        {
            vert = iter.next();
            if (vert.equals(searchVert))
            {
                FHvertex.popKeyType();
                return vert;
            }
        }

        FHvertex.popKeyType();
        return null;   // not found
    }
}

Pair.java

public class Pair<E, F>
{
    public E first;
    public F second;

    public Pair(E x, F y) { first = x; second = y; }

    public boolean equals(Object rhs)
    {
        Pair<E, F> other;
        other = (Pair<E, F>)rhs;
        return first.equals(other.first);
    }

    public int hashCode()
    {
        return first.hashCode();
    }
}

RouteFinder.java

package shortestPath;

import java.util.ArrayList;
import java.util.Arrays;

public class RouteFinder
{
   private ArrayList<Connection> readRoutesBetweenCities;

   /**
    * Parameterized constructor for an object of class RouteFinder.
    * Reads in a CSV file of source and destination cities and
    * converts it to a graph.
    * @param filePath The input file to parse.   
    */
   public RouteFinder(String filePath)
   {
      // TODO: Define the class BaseballFileReader
      BaseballFileReader reader = new BaseballFileReader();

      // TODO: Define the readFile() method which reads the CSV (Comma Separated Value)
      //       file of connections between cities  and creates a specified ArrayList
      //       of Connection objects.
      // 
      // NOTE: Catch all exceptions in the readFile() method.
      //       That means readFile() method should not throw an exception.
      readRoutesBetweenCities = reader.readFile(filePath);

      // Check the size of the resulting ArrayList object.
      if (readRoutesBetweenCities.size() < 1) 
      {
         System.out.println("WARNING: The list of cities is empty.");
         return;
      } 

      System.out.printf("The list of cities has %d items. \n", readRoutesBetweenCities.size());
   }
   
   /**
    * Accessor method returns the list of items read from input file.
    * @return the routes between cities.
    */
   public ArrayList<Connection> getConnectionsBetweenCities()
   {
      return readRoutesBetweenCities;
   }
   
    public static void main(String[] args) throws Exception
    {
      // NOTE: Make sure to use *relative* path instead of specifying the entire path. 
      //       Otherwise, your program will result in run time errors when the instructor
      //       tests your implementation.
      final String FILEPATH = "resources/BaseballCitiesEdgeCosts.txt";

      RouteFinder seeker = new RouteFinder(FILEPATH);
      ArrayList<Connection> connections = seeker.getConnectionsBetweenCities();

      // displays the prices of items in the input file
      System.out.println("Connections found between cities hosting Baseball games:");
      System.out.println(connections);
      
      
        // build graph
        FHgraph<String> baseBallRoutes = new FHgraph<String>();
      connections.forEach(current ->
            baseBallRoutes.addEdge(current.getSource(),current.getDestination(), current.getDistance()));
        
        baseBallRoutes.showAdjTable();

        // dijkstra called from inside
        // TODO: Update dijsktra() method to avoid paths which go through the
        //       requested list of cities to avoid.
        final String startingCity = "San Francisco";
        final String [] destinations = {"Boston", "Chicago A", "Chicago N"};
        final ArrayList<String> citiesToAvoid = new ArrayList(Arrays.asList(new String[]{"Los Angeles X", "Milwaukee"}));
        System.out.println("Showing distances to " + startingCity);
        System.out.println("Cities to avoid are " + citiesToAvoid);
        baseBallRoutes.showDistancesTo(startingCity, citiesToAvoid);
        System.out.println();

        for (String current : destinations)
        {
         // TODO: Update showShortestPath() to call dijkstra with requested cities to avoid.
            baseBallRoutes.showShortestPath(startingCity, current, citiesToAvoid);
            System.out.println();
        }

      System.out.println("Done.");
    }
}

BaseballCitiesEdgeCosts.txt

Atlanta, Baltimore, 576
Atlanta, Boston, 935
Atlanta, Chicago A, 586
Atlanta, Chicago N, 586
Atlanta, Cincinnati, 373
Atlanta, Cleveland, 555
Atlanta, Dallas, 719
Atlanta, Detroit, 597
Atlanta, Houston, 700
Atlanta, Kansas City, 675
Atlanta, Miami, 605
Atlanta, Milwaukee, 669
Atlanta, Minneapolis, 907
Atlanta, New York A, 745
Atlanta, New York N, 745
Atlanta, Philadelphia, 665
Atlanta, Pittsburgh, 521
Atlanta, St. Louis, 467
Atlanta, Tampa, 416
Atlanta, Toronto, 734
Atlanta, Washington DC, 871
Baltimore, Atlanta, 576
Baltimore, Boston, 359
Baltimore, Chicago A, 604
Baltimore, Chicago N, 604
Baltimore, Cincinnati, 419
Baltimore, Cleveland, 307
Baltimore, Detroit, 396
Baltimore, Kansas City, 960
Baltimore, Miami, 955
Baltimore, Milwaukee, 641
Baltimore, Minneapolis, 937
Baltimore, New York A, 169
Baltimore, New York N, 169
Baltimore, Philadelphia, 89
Baltimore, Pittsburgh, 196
Baltimore, St. Louis, 730
Baltimore, Tampa, 851
Baltimore, Toronto, 333
Baltimore, Washington DC, 57
Boston, Atlanta, 935
Boston, Baltimore, 359
Boston, Chicago A, 849
Boston, Chicago N, 849
Boston, Cincinnati, 733
Boston, Cleveland, 549
Boston, Detroit, 611
Boston, Milwaukee, 855
Boston, New York A, 189
Boston, New York N, 189
Boston, Philadelphia, 270
Boston, Pittsburgh, 481
Boston, Toronto, 429
Boston, Washington DC, 633
Chicago A, Atlanta, 586
Chicago A, Baltimore, 604
Chicago A, Boston, 849
Chicago A, Cincinnati, 250
Chicago A, Cleveland, 307
Chicago A, Dallas, 801
Chicago A, Denver, 916
Chicago A, Detroit, 237
Chicago A, Houston, 938
Chicago A, Kansas City, 412
Chicago A, Milwaukee, 81
Chicago A, Minneapolis, 354
Chicago A, New York A, 711
Chicago A, New York N, 711
Chicago A, Philadelphia, 664
Chicago A, Pittsburgh, 409
Chicago A, St. Louis, 262
Chicago A, Toronto, 468
Chicago A, Washington DC, 955
Chicago N, Atlanta, 586
Chicago N, Baltimore, 604
Chicago N, Boston, 849
Chicago N, Cincinnati, 250
Chicago N, Cleveland, 307
Chicago N, Dallas, 801
Chicago N, Denver, 916
Chicago N, Detroit, 237
Chicago N, Houston, 938
Chicago N, Kansas City, 412
Chicago N, Milwaukee, 81
Chicago N, Minneapolis, 354
Chicago N, New York A, 711
Chicago N, New York N, 711
Chicago N, Philadelphia, 664
Chicago N, Pittsburgh, 409
Chicago N, St. Louis, 262
Chicago N, Toronto, 468
Chicago N, Washington DC, 955
Cincinnati, Atlanta, 373
Cincinnati, Baltimore, 419
Cincinnati, Boston, 733
Cincinnati, Chicago A, 250
Cincinnati, Chicago N, 250
Cincinnati, Cleveland, 217
Cincinnati, Dallas, 817
Cincinnati, Detroit, 230
Cincinnati, Houston, 896
Cincinnati, Kansas City, 541
Cincinnati, Miami, 955
Cincinnati, Milwaukee, 324
Cincinnati, Minneapolis, 604
Cincinnati, New York A, 567
Cincinnati, New York N, 567
Cincinnati, Philadelphia, 501
Cincinnati, Pittsburgh, 256
Cincinnati, St. Louis, 308
Cincinnati, Tampa, 779
Cincinnati, Toronto, 407
Cincinnati, Washington DC, 401
Cleveland, Atlanta, 555
Cleveland, Baltimore, 307
Cleveland, Boston, 549
Cleveland, Chicago A, 307
Cleveland, Chicago N, 307
Cleveland, Cincinnati, 217
Cleveland, Detroit, 90
Cleveland, Kansas City, 698
Cleveland, Milwaukee, 334
Cleveland, Minneapolis, 629
Cleveland, New York A, 403
Cleveland, New York N, 403
Cleveland, Philadelphia, 358
Cleveland, Pittsburgh, 114
Cleveland, St. Louis, 491
Cleveland, Tampa, 937
Cleveland, Toronto, 188
Cleveland, Washington DC, 304
Dallas, Atlanta, 719
Dallas, Chicago A, 801
Dallas, Chicago N, 801
Dallas, Cincinnati, 817
Dallas, Denver, 661
Dallas, Detroit, 999
Dallas, Houston, 225
Dallas, Kansas City, 454
Dallas, Milwaukee, 857
Dallas, Minneapolis, 863
Dallas, Phoenix, 883
Dallas, St. Louis, 547
Dallas, Tampa, 916
Denver, Chicago A, 916
Denver, Chicago N, 916
Denver, Dallas, 661
Denver, Houston, 877
Denver, Kansas City, 557
Denver, Los Angeles A, 829
Denver, Los Angeles N, 829
Denver, Milwaukee, 912
Denver, Minneapolis, 698
Denver, Oakland, 938
Denver, Phoenix, 585
Denver, San Diego, 832
Denver, San Francisco, 946
Denver, St. Louis, 794
Detroit, Atlanta, 597
Detroit, Baltimore, 396
Detroit, Boston, 611
Detroit, Chicago A, 237
Detroit, Chicago N, 237
Detroit, Cincinnati, 230
Detroit, Cleveland, 90
Detroit, Dallas, 999
Detroit, Kansas City, 643
Detroit, Milwaukee, 251
Detroit, Minneapolis, 542
Detroit, New York A, 480
Detroit, New York N, 480
Detroit, Philadelphia, 441
Detroit, Pittsburgh, 250
Detroit, St. Louis, 454
Detroit, Tampa, 994
Detroit, Toronto, 206
Detroit, Washington DC, 393
Houston, Atlanta, 700
Houston, Chicago A, 938
Houston, Chicago N, 938
Houston, Cincinnati, 896
Houston, Dallas, 225
Houston, Denver, 877
Houston, Kansas City, 646
Houston, Miami, 965
Houston, St. Louis, 679
Houston, Tampa, 789
Kansas City, Atlanta, 675
Kansas City, Baltimore, 960
Kansas City, Chicago A, 412
Kansas City, Chicago N, 412
Kansas City, Cincinnati, 541
Kansas City, Cleveland, 698
Kansas City, Dallas, 454
Kansas City, Denver, 557
Kansas City, Detroit, 643
Kansas City, Houston, 646
Kansas City, Milwaukee, 441
Kansas City, Minneapolis, 411
Kansas City, Pittsburgh, 779
Kansas City, St. Louis, 237
Kansas City, Toronto, 846
Kansas City, Washington DC, 940
Los Angeles A, Denver, 829
Los Angeles A, Oakland, 343
Los Angeles A, Phoenix, 356
Los Angeles A, San Diego, 111
Los Angeles A, San Francisco, 347
Los Angeles A, Seattle, 959
Los Angeles N, Denver, 829
Los Angeles N, Oakland, 343
Los Angeles N, Phoenix, 356
Los Angeles N, San Diego, 111
Los Angeles N, San Francisco, 347
Los Angeles N, Seattle, 959
Miami, Atlanta, 605
Miami, Baltimore, 955
Miami, Cincinnati, 955
Miami, Houston, 965
Miami, Tampa, 204
Milwaukee, Atlanta, 669
Milwaukee, Baltimore, 641
Milwaukee, Boston, 855
Milwaukee, Chicago A, 81
Milwaukee, Chicago N, 81
Milwaukee, Cincinnati, 324
Milwaukee, Cleveland, 334
Milwaukee, Dallas, 857
Milwaukee, Denver, 912
Milwaukee, Detroit, 251
Milwaukee, Kansas City, 441
Milwaukee, Minneapolis, 298
Milwaukee, New York A, 732
Milwaukee, New York N, 732
Milwaukee, Philadelphia, 692
Milwaukee, Pittsburgh, 445
Milwaukee, St. Louis, 327
Milwaukee, Toronto, 430
Milwaukee, Washington DC, 634
Minneapolis, Atlanta, 907
Minneapolis, Baltimore, 937
Minneapolis, Chicago A, 354
Minneapolis, Chicago N, 354
Minneapolis, Cincinnati, 604
Minneapolis, Cleveland, 629
Minneapolis, Dallas, 863
Minneapolis, Denver, 698
Minneapolis, Detroit, 542
Minneapolis, Kansas City, 411
Minneapolis, Milwaukee, 298
Minneapolis, Philadelphia, 983
Minneapolis, Pittsburgh, 741
Minneapolis, St. Louis, 466
Minneapolis, Toronto, 691
Minneapolis, Washington DC, 931
New York A, Atlanta, 745
New York A, Baltimore, 169
New York A, Boston, 189
New York A, Chicago A, 711
New York A, Chicago N, 711
New York A, Cincinnati, 567
New York A, Cleveland, 403
New York A, Detroit, 480
New York A, Milwaukee, 732
New York A, Philadelphia, 80
New York A, Pittsburgh, 314
New York A, St. Louis, 871
New York A, Toronto, 341
New York A, Washington DC, 328
New York N, Atlanta, 745
New York N, Baltimore, 169
New York N, Boston, 189
New York N, Chicago A, 711
New York N, Chicago N, 711
New York N, Cincinnati, 567
New York N, Cleveland, 403
New York N, Detroit, 480
New York N, Milwaukee, 732
New York N, Philadelphia, 80
New York N, Pittsburgh, 314
New York N, St. Louis, 871
New York N, Toronto, 341
New York N, Washington DC, 328
Oakland, Denver, 938
Oakland, Los Angeles A, 343
Oakland, Los Angeles N, 343
Oakland, Phoenix, 645
Oakland, San Diego, 454
Oakland, San Francisco, 8
Oakland, Seattle, 676
Philadelphia, Atlanta, 665
Philadelphia, Baltimore, 89
Philadelphia, Boston, 270
Philadelphia, Chicago A, 664
Philadelphia, Chicago N, 664
Philadelphia, Cincinnati, 501
Philadelphia, Cleveland, 358
Philadelphia, Detroit, 441
Philadelphia, Milwaukee, 692
Philadelphia, Minneapolis, 983
Philadelphia, New York A, 80
Philadelphia, New York N, 80
Philadelphia, Pittsburgh, 257
Philadelphia, St. Louis, 808
Philadelphia, Tampa, 927
Philadelphia, Toronto, 335
Philadelphia, Washington DC, 199
Pittsburgh, Atlanta, 521
Pittsburgh, Baltimore, 196
Pittsburgh, Boston, 481
Pittsburgh, Chicago A, 409
Pittsburgh, Chicago N, 409
Pittsburgh, Cincinnati, 256
Pittsburgh, Cleveland, 114
Pittsburgh, Detroit, 250
Pittsburgh, Kansas City, 779
Pittsburgh, Milwaukee, 445
Pittsburgh, Minneapolis, 741
Pittsburgh, New York A, 314
Pittsburgh, New York N, 314
Pittsburgh, Philadelphia, 257
Pittsburgh, St. Louis, 557
Pittsburgh, Tampa, 874
Pittsburgh, Toronto, 223
Pittsburgh, Washington DC, 189
Phoenix, Dallas, 883
Phoenix, Denver, 585
Phoenix, Los Angeles A, 356
Phoenix, Los Angeles N, 356
Phoenix, Oakland, 645
Phoenix, San Diego, 298
Phoenix, San Francisco, 652
San Diego, Denver, 832
San Diego, Los Angeles A, 111
San Diego, Los Angeles N, 111
San Diego, Oakland, 454
San Diego, Phoenix, 298
San Diego, San Francisco, 458
San Francisco, Denver, 946
San Francisco, Los Angeles A, 347
San Francisco, Los Angeles N, 347
San Francisco, Oakland, 8
San Francisco, Phoenix, 652
San Francisco, San Diego, 458
San Francisco, Seattle, 678
Seattle, Los Angeles A, 959
Seattle, Los Angeles N, 959
Seattle, Oakland, 676
Seattle, San Francisco, 678
St. Louis, Atlanta, 467
St. Louis, Baltimore, 730
St. Louis, Chicago A, 262
St. Louis, Chicago N, 262
St. Louis, Cincinnati, 308
St. Louis, Cleveland, 491
St. Louis, Dallas, 547
St. Louis, Denver, 794
St. Louis, Detroit, 454
St. Louis, Houston, 679
St. Louis, Kansas City, 237
St. Louis, Milwaukee, 327
St. Louis, Minneapolis, 466
St. Louis, New York A, 871
St. Louis, New York N, 871
St. Louis, Philadelphia, 808
St. Louis, Pittsburgh, 557
St. Louis, Tampa, 861
St. Louis, Toronto, 660
St. Louis, Washington DC, 708
Tampa, Atlanta, 416
Tampa, Baltimore, 851
Tampa, Cincinnati, 779
Tampa, Cleveland, 937
Tampa, Dallas, 916
Tampa, Detroit, 994
Tampa, Houston, 789
Tampa, Miami, 204
Tampa, Philadelphia, 927
Tampa, Pittsburgh, 874
Tampa, St. Louis, 861
Toronto, Atlanta, 734
Toronto, Baltimore, 333
Toronto, Boston, 429
Toronto, Chicago A, 468
Toronto, Chicago N, 468
Toronto, Cincinnati, 407
Toronto, Cleveland, 188
Toronto, Detroit, 206
Toronto, Kansas City, 846
Toronto, Milwaukee, 430
Toronto, Minneapolis, 691
Toronto, New York A, 341
Toronto, New York N, 341
Toronto, Philadelphia, 335
Toronto, Pittsburgh, 223
Toronto, St. Louis, 660
Toronto, Washington DC, 350
Washington DC, Atlanta, 871
Washington DC, Baltimore, 57
Washington DC, Boston, 633
Washington DC, Chicago A, 955
Washington DC, Chicago N, 955
Washington DC, Cincinnati, 401
Washington DC, Cleveland, 304
Washington DC, Detroit, 393
Washington DC, Kansas City, 940
Washington DC, Milwaukee, 634
Washington DC, Minneapolis, 931
Washington DC, New York A, 328
Washington DC, New York N, 328
Washington DC, Philadelphia, 199
Washington DC, Pittsburgh, 189
Washington DC, St. Louis, 708
Washington DC, Toronto, 350