Shortest path issue

Question

Hey guys, first...Happy thanksgiving :)
Ok, so I'm on my last assignment for my amazingly taught Data Structures class. I battled my way successfully through recursion, binary trees, redblack trees, 234 trees, B Trees, and heaps!...no issues at all!....but, now I have hit graphs. I understand the concept, but my latest assignment has me a bit frustrated..Im so close to finishing I can taste it!!....I just cant find the spoon..
Here we go:
We are given a graph on paper. It has circles (verteci) representing cities in the USA. These circles are connected by lines (edges) representing the distance between the cities. Also, the lines have arrows pointing the direction they may be traversed.
We are to construct the graph in the computer, and then compute the shortest path from washington (Vertex 0) to every other city.
I managed to construct the graph, and it will find the shortest path no problem. My only issue is that, it wants us to print the path it took, not just the destination and total distance....
I have tried using a stack to push the verteci onto as theyre visited, but im not getting happy results.
I should also mention, this code is taken out of the book with modifications by me so that it can add edges and verteci, and it now accepts String types for the vertex labels instead of characters.
Here is my code
PATH.JAVA (the important part)
// path.java
// demonstrates shortest path with weighted, directed graphs
// to run this program: C>java PathApp
import java.lang.*;
import java.io.*;
class DistPar               // distance and parent
{                           // items stored in sPath array
    public int distance;    // distance from start to this vertex
    public int parentVert;  // current parent of this vertex
    public DistPar(int pv, int d)  // constructor
        distance = d;
        parentVert = pv;
}  // end class DistPar
class Vertex
    public String label;        // label (e.g. 'A')
    public boolean isInTree;
    public Vertex(String lab)   // constructor
        label = lab;
        isInTree = false;
}  // end class Vertex
class Graph
    private final int MAX_VERTS = 20;
    private final int INFINITY = 1000000;
    private Vertex vertexList[];    // list of vertices
    private int adjMat[][];         // adjacency matrix
    private int nVerts;             // current number of vertices
    private int nTree;              // number of verts in tree
    private DistPar sPath[];        // array for shortest-path data
    private int currentVert;        // current vertex
    private int startToCurrent;     // distance to currentVert
    private stack path_taken;       // stack to record path taken
    public Graph()                  // constructor
        vertexList = new Vertex[MAX_VERTS];
                                         // adjacency matrix
        adjMat = new int[MAX_VERTS][MAX_VERTS];
        nVerts = 0;
        nTree  = 0;
        for(int j=0; j<MAX_VERTS; j++)      // set adjacency
            for(int k=0; k<MAX_VERTS; k++)  //     matrix
                adjMat[j][k] = INFINITY;    //     to infinity
        sPath = new DistPar[MAX_VERTS];     // shortest paths
        path_taken = new stack(MAX_VERTS);
    }  // end constructor
    public void addVertex(String lab)
        vertexList[nVerts++] = new Vertex(lab);
    public void addEdge(int start, int end, int weight)
        adjMat[start][end] = weight;  // (directed)
    public void path()                // find all shortest paths
        int startTree = 0;             // start at vertex 0
        vertexList[startTree].isInTree = true;
        nTree = 1;                     // put it in tree
      // transfer row of distances from adjMat to sPath
        for(int j=0; j<nVerts; j++)
            int tempDist = adjMat[startTree][j];
            sPath[j] = new DistPar(startTree, tempDist);
      // until all vertices are in the tree
        while(nTree < nVerts)
            int indexMin = getMin();    // get minimum from sPath
            int minDist = sPath[indexMin].distance;
            if(minDist == INFINITY)     // if all infinite
            {                        // or in tree,
                System.out.println("There are unreachable vertices");
                break;                   // sPath is complete
            else
            {                        // reset currentVert
                currentVert = indexMin;  // to closest vert
                startToCurrent = sPath[indexMin].distance;
                // minimum distance from startTree is
                // to currentVert, and is startToCurrent
            // put current vertex in tree
            vertexList[currentVert].isInTree = true;
            nTree++;
            path_taken.push(sPath[indexMin]);
            adjust_sPath();             // update sPath[] array
        }  // end while(nTree<nVerts)
        displayPaths();                // display sPath[] contents
        nTree = 0;                     // clear tree
        for(int j=0; j<nVerts; j++)
            vertexList[j].isInTree = false;
    }  // end path()
    public int getMin()               // get entry from sPath
    {                              //    with minimum distance
        int minDist = INFINITY;        // assume minimum
        int indexMin = 0;
        for(int j=1; j<nVerts; j++)    // for each vertex,
        {                           // if it's in tree and
            if( !vertexList[j].isInTree &&  // smaller than old one
                               sPath[j].distance < minDist )
                minDist = sPath[j].distance;
                indexMin = j;            // update minimum
        }  // end for
        return indexMin;               // return index of minimum
     }  // end getMin()
    public void adjust_sPath()
      // adjust values in shortest-path array sPath
        int column = 1;                // skip starting vertex
        while(column < nVerts)         // go across columns
         // if this column's vertex already in tree, skip it
            if( vertexList[column].isInTree )
                column++;
                continue;
         // calculate distance for one sPath entry
                       // get edge from currentVert to column
            int currentToFringe = adjMat[currentVert][column];
                       // add distance from start
            int startToFringe = startToCurrent + currentToFringe;
                       // get distance of current sPath entry
            int sPathDist = sPath[column].distance;
         // compare distance from start with sPath entry
            if(startToFringe < sPathDist)   // if shorter,
            {                            // update sPath
                sPath[column].parentVert = currentVert;
                sPath[column].distance = startToFringe;
            column++;
         }  // end while(column < nVerts)
    }  // end adjust_sPath()
    public void displayPaths()
        for(int j=0; j<nVerts; j++) // display contents of sPath[]
            System.out.print(vertexList[j].label + "="); // B=
            if(sPath[j].distance == INFINITY)
                System.out.print("inf");                  // inf
            else
                System.out.print(sPath[j].distance);      // 50
                String parent = vertexList[ sPath[j].parentVert ].label;
                System.out.print(" (" + parent + ") ");       // (A)
        System.out.println("");
        System.out.println("PRINTING path_taken");
        DistPar thing = null;
        while((thing = path_taken.pop()) != null)
            System.out.println(" " + vertexList[thing.parentVert].label + " "+ thing.distance);
}  // end class GraphSTACK.JAVA (my stack class)
// stack.java
// demonstrates stacks
// to run this program: C>java StackApp
class stack
    private int maxSize;        // size of stack array
    private DistPar[] stackArray;
    private int top;            // top of stack
    public stack(int s)         // constructor
        maxSize = s;             // set array size
        stackArray = new DistPar[maxSize];  // create array
        top = -1;                // no items yet
    public void push(DistPar j)    // put item on top of stack
        stackArray[++top] = j;     // increment top, insert item
    public DistPar pop()           // take item from top of stack
        return stackArray[top--];  // access item, decrement top
    public DistPar peek()          // peek at top of stack
        return stackArray[top];
    public boolean isEmpty()    // true if stack is empty
        return (top == -1);
    public boolean isFull()     // true if stack is full
        return (top == maxSize-1);
}PATHAPP.JAVA (test program..builds the graph and calls path())
class PathApp
    public static void main(String[] args)
        Graph theGraph = new Graph();
        theGraph.addVertex("Washington");
        theGraph.addVertex("Atlanta");
        theGraph.addVertex("Houston");
        theGraph.addVertex("Denver");
        theGraph.addVertex("Dallas");
        theGraph.addVertex("Chicago");
        theGraph.addVertex("Austin");
        theGraph.addEdge(0,1,600);
        theGraph.addEdge(1,0,600);
        theGraph.addEdge(0,4,1300);
        theGraph.addEdge(4,3,780);
        theGraph.addEdge(3,1,1400);
        theGraph.addEdge(1,2,800);
        theGraph.addEdge(2,1,800);
        theGraph.addEdge(4,5,900);
        theGraph.addEdge(4,6,200);
        theGraph.addEdge(6,4,200);
        theGraph.addEdge(6,2,160);
        theGraph.addEdge(3,5,1000);
        theGraph.addEdge(5,3,1000);
        System.out.println("Shortest Paths");
        theGraph.path();
        //theGraph.displayPaths();
        System.out.println();
}Im mostly having trouble comprehending the Path.java file. A few friends and I stared at it for a few hours and couldnt get it to do what we wanted...
path_taken is the stack I added in to try and push/pop the verteci as theyre traversed, but with what I stuck in right now, it still just prints the most recently visited vertex, and the sum of the distances.
Any help is greatly appreciated!
Thanks :)
----Arkhan

Answer 1

If your graph is G(V, E), and you're trying to get to vertex v_end, then create a new graph G'(V', E') whereV' = (V x N) U {v_end'}
    (v_end' is a new object)
E' = {((u, t), (v, t + f(u, v, t))) : (u, v) in E, t in N} U
     {((u, t), (u, t + 1)) : u in V, t in N} U
     {((v_end, t), v_end') : t in N}G' is infinite, so you'll need to use a lazy graph structure. Then just use Dijkstra from (v_start, 0) to v_end'.