- 478 - Figure 14.2: The GraphW Workshop applet Now find this graph's minimum spanning tree by stepping through the algorithm with the Tree key. The result should be the minimum spanning tree shown in Figure 14.3. Figure 14.3: The minimum spanning tree The applet should discover that the minimum spanning tree consists of the edges AD, AB, BE, EC, and CF, for a total edge weight of 28. The order in which the edges are specified is unimportant. If you start at a different vertex you will create a tree with the same edges, but in a different order. Send Out the Surveyors The algorithm for constructing the minimum spanning tree is a little involved, so we're going to introduce it using an analogy involving cable TV employees. You are one employee—a manager, of course—and there are also various surveyors. A computer algorithm (unless perhaps it's a neural network) doesn't "know" about all the data in a given problem at once; it can't deal with the big picture. It must acquire the data little by little, modifying its view of things as it goes along. With graphs, algorithms tend to start at some vertex and work outward, acquiring data about nearby vertices before finding out about vertices farther away. We've seen examples of this in the depth-first and breadth-first searches in the last chapter. In a similar way, we're going to assume that you don't start out knowing the costs of installing the cable TV line between all the pairs of towns in Magnaguena. Acquiring this information takes time. That's where the surveyors come in. Starting in Ajo You start by setting up an office in Ajo. (You could start in any town, but Ajo has the best restaurants.) Only two towns are reachable from Ajo: Bordo and Danza (refer to Figure 14.1). You hire two tough, jungle-savvy surveyors and send them out along the dangerous wilderness trails, one to Bordo and one to Danza. Their job is to determine the cost of installing cable along these routes. The first surveyor arrives in Bordo, having completed her survey, and calls you on her cellular phone; she says it will cost 6 million dollars to install the cable link between Ajo and Bordo. The second surveyor, who has had some trouble with crocodiles, reports a little later from Danza that the Ajo–Danza link, which crosses more level country, will cost only 4 million dollars. You make a list: • Ajo–Danza, $4 million • Ajo–Bordo, $6 million You always list the links in order of increasing cost; we'll see why this is a good idea - 479 - soon. Building the Ajo–Danza Link At this point you figure you can send out the construction crew to actually install the cable from Ajo to Danza. How can you be sure the Ajo–Danza route will eventually be part of the cheapest solution (the minimum spanning tree)? So far, you only know the cost of two links in the system. Don't you need more information? To get a feel for this situation, try to imagine some other route linking Ajo to Danza that would be cheaper than the direct link. If it doesn't go directly to Danza, this other route must go through Bordo and circle back to Danza, possibly via one or more other towns. But you already know the link to Bordo is more expensive, at 6 million dollars,than the link to Danza, at 4. So even if the remaining links in this hypothetical circle route are cheap, as shown in Figure 14.4, it will still be more expensive to get to Danza by going through Bordo. Also, it will be more expensive to get to towns on the circle route, like X, by going through Bordo than by going through Danza. Figure 14.4: Hypothetical circle route We conclude that the Ajo–Danza route will be part of the minimum spanning tree. This isn't a formal proof (which is beyond the scope of this book), but it does suggest your best bet is to pick the cheapest link. So you build the Ajo–Danza link and install an office in Danza. Why do you need an office? Due to a Magnaguena government regulation, you must install an office in a town before you can send out surveyors from that town to adjacent towns. In graph terms, you must add a vertex to the tree before you can learn the weight of the edges leading away from that vertex. All towns with offices are connected by cable with each other; towns with no offices are not yet connected. Building the Ajo–Bordo Link Once you've completed the Ajo–Danza link and built your office in Danza, you can send out surveyors from Danza to all the towns reachable from there. These are Bordo, Colina, and Erizo. The surveyors reach their destinations and report back costs of 7, 8, and 12 million dollars, respectively. (Of course you don't send a surveyor to Ajo because you've already surveyed the Ajo–Danza route and installed its cable.) Now you know the costs of four links from towns with offices to towns with no offices: • Ajo–Bordo, $6 million • Danza–Bordo, $7 million • Danza–Colina, $8 million • Danza–Erizo, $12 million - 480 - Why isn't the Ajo–Danza link still on the list? Because you've already installed the cable there; there's no point giving any further consideration to this link. The route on which a cable has just been installed is always removed from the list. At this point it may not be obvious what to do next. There are many potential links to choose from. What do you imagine is the best strategy now? Here's the rule: REMEMBER Rule: From the list, always pick the cheapest edge. Actually, you already followed this rule when you chose which route to follow from Ajo; the Ajo–Danza edge was the cheapest. Here the cheapest edge is Ajo–Bordo, so you install a cable link from Ajo to Bordo for a cost of 6 million dollars, and build an office in Bordo. Let's pause for a moment and make a general observation. At a given time in the cable system construction, there are three kinds of towns: 1. Towns that have offices and are linked by cable. (In graph terms they're in the minimum spanning tree.) 2. Towns that aren't linked yet and have no office, but for which you know the cost to link them to at least one town with an office. We can call these "fringe" towns. 3. Towns you don't know anything about. At this stage, Ajo, Danza, and Bordo are in category 1, Colina and Erizo are in category 2, and Flor is in category 3, as shown in Figure 14.5. As we work our way through the algorithm, towns move from category 3 to 2, and from 2 to 1. Figure 14.5: Partway through the minimum spanning tree algorithm Building the Bordo–Erizo Link At this point, Ajo, Danza, and Bordo are connected to the cable system and have offices. You already know the costs from Ajo and Danza to towns in category 2, but you don't know these costs from Bordo. So from Bordo you send out surveyors to Colina and Erizo. They report back costs of 10 to Colina and 7 to Erizo. Here's the new list: • Bordo–Erizo, $7 million • Danza–Colina, $8 million • Bordo–Colina, $10 million • Danza–Erizo, $12 million - 481 - The Danza–Bordo link was on the previous list but is not on this one because, as we noted, there's no point in considering links to towns that are already connected, even by an indirect route. From this list we can see that the cheapest route is Bordo–Erizo, at 7 million dollars. You send out the crew to install this cable link, and you build an office in Erizo (refer to Figure 14.3). Building the Erizo–Colina Link From Erizo the surveyors report back costs of 5 to Colina and 7 to Flor. The Danza–Erizo link from the previous list must be removed because Erizo is now a connected town. Your new list is • Erizo–Colina, $5 million • Erizo–Flor, $7 million • Danza–Colina, $8 million • Bordo–Colina, $10 million The cheapest of these links is Erizo–Colina, so you built this link and install an office in Colina. And, Finally, the Colina–Flor Link The choices are narrowing. After removing already linked towns, your list now shows only • Colina–Flor, $6 million • Erizo–Flor, $7 million You install the last link of cable from Colina to Flor, build an office in Flor, and you're done. You know you're done because there's now an office in every town. You've constructed the cable route Ajo–Danza, Ajo–Bordo, Bordo–Erizo, Erizo–Colina, and Colina–Flor, as shown earlier in Figure 14.3 . This is the cheapest possible route linking the six towns of Magnaguena. Creating the Algorithm Using the somewhat fanciful idea of installing a cable TV system, we've shown the main ideas behind the minimum spanning tree for weighted graphs. Now let's see how we'd go about creating the algorithm for this process. The Priority Queue The key activity in carrying out the algorithm, as described in the cable TV example, was maintaining a list of the costs of links between pairs of cities. We decided where to build the next link by selecting the minimum of these costs. A list in which we repeatedly select the minimum value suggests a priority queue as an appropriate data structure, and in fact this turns out to be an efficient way to handle the minimum spanning tree problem. Instead of a list or array, we use a priority queue. In a serious program this priority queue might be based on a heap, as described in Chapter 12, "Heaps." This would speed up operations on large priority queues. However, in our - 482 - demonstration program we'll use a priority queue based on a simple array. Outline of the Algorithm Let's restate the algorithm in graph terms (as opposed to cable TV terms): Start with a vertex, put it in the tree. Then repeatedly do the following: 1. Find all the edges from the newest vertex to other vertices that aren't in the tree. Put these edges in the priority queue. 2. Pick the edge with the lowest weight, and add this edge and its destination vertex to the tree. Do these steps until all the vertices are in the tree. At that point, you're done. In step 1, "newest" means most recently installed in the tree. The edges for this step can be found in the adjacency matrix. After step 1, the list will contain all the edges from vertices in the tree to vertices on the fringe. Extraneous Edges In maintaining the list of links, we went to some trouble to remove links that led to a town that had recently become connected. If we didn't do this, we would have ended up installing unnecessary cable links. In a programming algorithm we must likewise make sure that we don't have any edges in the priority queue that lead to vertices that are already in the tree. We could go through the queue looking for and removing any such edges each time we added a new vertex to the tree. As it turns out, it is easier to keep only one edge from the tree to a given fringe vertex in the priority queue at any given time. That is, the queue should contain only one edge to each category 2 vertex. You'll see that this is what happens in the GraphW Workshop applet. There are fewer edges in the priority queue than you might expect; just one entry for each category 2 vertex. Step through the minimum spanning tree for Figure 14.1 and verify that this is what happens. Table 14.1 shows how edges with duplicate destinations have been removed from the priority queue. Table 14.1: Edge pruning Step Number Unpruned Edge List Pruned Edge List (in PriorityQueue) Duplicate Removed from Priority Queue 1 AB6, AD4 AB6, AD4 2 DE12, DC8, DB7, AB6 DE12, DC8, AB6 DB7(AB6) 3 DE12, BC10, DC8, BE7 DC8, BE7 DE12(BE7), BC10(DC8) - 483 - 4 BC10, DC8, EF7, EC5 EF7, EC5 BC10(EC5), DC8(EC5) 5 EF7, CF6 CF6 EF7 Remember that an edge consists of a letter for the source (starting) vertex of the edge, a letter for the destination (ending vertex), and a number for the weight. The second column in this table corresponds to the lists you kept when constructing the cable TV system. It shows all edges from category 1 vertices (those in the tree) to category 2 vertices (those with at least one known edge from a category 1 vertex). The third column is what you see in the priority queue when you run the GraphW applet. Any edge with the same destination vertex as another edge, and which has a greater weight, has been removed. The fourth column shows the edges that have been removed, and, in parentheses, the edge with the smaller weight that superseded it and remains in the queue. Remember that as you go from step to step the last entry on the list is always removed because this edge is added to the tree. Looking for Duplicates in the Priority Queue How do we make sure there is only one edge per category 2 vertex? Each time we add an edge to the queue, we make sure there's no other edge going to the same destination. If there is, we keep only the one with the smallest weight. This necessitates looking through the priority queue item by item, to see if there's such a duplicate edge. Priority queues are not designed for random access, so this is not an efficient activity. However, violating the spirit of the priority queue is necessary in this situation. Java Code The method that creates the minimum spanning tree for a weighted graph, mstw(), follows the algorithm outlined above. As in our other graph programs, it assumes there's a list of vertices in vertexList[], and that it will start with the vertex at index 0. The currentVert variable represents the vertex most recently added to the tree. Here's the code for mstw(): public void mstw() // minimum spanning tree { currentVert = 0; // start at 0 while(nTree < nVerts-1) // while not all verts in tree { // put currentVert in tree vertexList[currentVert].isInTree = true; nTree++; // insert edges adjacent to currentVert into PQ for(int j=0; j<nVerts; j++) // for each vertex, { if(j==currentVert) // skip if it's us continue; if(vertexList[j].isInTree) // skip if in the tree - 484 - continue; int distance = adjMat[currentVert][j]; if( distance == INFINITY) // skip if no edge continue; putInPQ(j, distance); // put it in PQ (maybe) } if(thePQ.size()==0) // no vertices in PQ? { System.out.println(" GRAPH NOT CONNECTED"); return; } // remove edge with minimum distance, from PQ Edge theEdge = thePQ.removeMin(); int sourceVert = theEdge.srcVert; currentVert = theEdge.destVert; // display edge from source to current System.out.print( vertexList[sourceVert].label ); System.out.print( vertexList[currentVert].label ); System.out.print(" "); } // end while(not all verts in tree) // mst is complete for(int j=0; j<nVerts; j++) // unmark vertices vertexList[j].isInTree = false; } // end mstw() The algorithm is carried out in the while loop, which terminates when all vertices are in the tree. Within this loop the following activities take place: 1. The current vertex is placed in the tree. 2. The edges adjacent to this vertex are placed in the priority queue (if appropriate). 3. The edge with the minimum weight is removed from priority queue. The destination vertex of this edge becomes the current vertex. Let's look at these steps in more detail. In step 1, the currentVert is placed in the tree by marking its isInTree field. In step 2, the edges adjacent to this vertex are considered for insertion in the priority queue. The edges are examined by scanning across the row whose number is currentVert in the adjacency matrix. An edge is placed in the queue unless one of these conditions is true: • The source and destination vertices are the same. • The destination vertex is in the tree. • There is no edge to this destination. If none of these conditions is true, the putInPQ() method is called to put the edge in the priority queue. Actually, this routine doesn't always put the edge in the queue either, as - 485 - we'll see in a moment. In step 3, the edge with the minimum weight is removed from the priority queue. This edge and its destination vertex are added to the tree, and the source vertex (currentVert) and destination vertex are displayed. At the end of mstw(), the vertices are removed from the tree by resetting their isInTree variables. That isn't strictly necessary in this program, because only one tree is created from the data. However, it's good housekeeping to restore the data to its original form when you finish with it. As we noted, the priority queue should contain only one edge with a given destination vertex. The putInPQ() method makes sure this is true. It calls the find() method of the PriorityQ class, which has been doctored to find the edge with a specified destination vertex. If there is no such vertex, and find() therefore returns –1, then putInPQ() simply inserts the edge into the priority queue. However, if such an edge does exist, putInPQ() checks to see whether the existing edge or the new proposed edge has the lower weight. If it's the old edge, no change is necessary. If the new one has a lower weight, the old edge is removed from the queue and the new one is installed. Here's the code for putInPQ(): public void putInPQ(int newVert, int newDist) { // is there another edge with the same destination vertex? int queueIndex = thePQ.find(newVert); // got edge's index if(queueIndex != -1) // if there is one, { // get edge Edge tempEdge = thePQ.peekN(queueIndex); int oldDist = tempEdge.distance; if(oldDist > newDist) // if new edge shorter, { thePQ.removeN(queueIndex); // remove old edge Edge theEdge = new Edge(currentVert, newVert, newDist); thePQ.insert(theEdge); // insert new edge } // else no action; just leave the old vertex there } // end if else // no edge with same destination vertex { // so insert new one Edge theEdge = new Edge(currentVert, newVert, newDist); thePQ.insert(theEdge); } } // end putInPQ() The mstw.java Program The PriorityQ class uses an array to hold the members. As we noted, in a program dealing with large graphs a heap would be more appropriate than the array shown here. The PriorityQ class has been augmented with various methods. It can, as we've seen, find an edge with a given destination vertex with find(). It can also peek at an arbitrary member with peekN() and remove an arbitrary member with removeN(). Most of the rest of this program you've seen before. Listing 14.1 shows the complete mstw.java program. - 486 - Listing 14.1 The mstw.java Program // mstw.java // demonstrates minimum spanning tree with weighted graphs // to run this program: C>java MSTWApp import java.awt.*; //////////////////////////////////////////////////////////////// class Edge { public int srcVert; // index of a vertex starting edge public int destVert; // index of a vertex ending edge public int distance; // distance from src to dest public Edge(int sv, int dv, int d) // constructor { srcVert = sv; destVert = dv; distance = d; } } // end class Edge //////////////////////////////////////////////////////////////// class PriorityQ { // array in sorted order, from max at 0 to min at size-1 private final int SIZE = 20; private Edge[] queArray; private int size; public PriorityQ() // constructor { queArray = new Edge[SIZE]; size = 0; } public void insert(Edge item) // insert item in sorted order { int j; for(j=0; j<size; j++) // find place to insert if( item.distance >= queArray[j].distance ) break; for(int k=size-1; k>=j; k ) // move items up queArray[k+1] = queArray[k]; queArray[j] = item; // insert item size++; } public Edge removeMin() // remove minimum item - 487 - { return queArray[ size]; } public void removeN(int n) // remove item at n { for(int j=n; j<size-1; j++) // move items down queArray[j] = queArray[j+1]; size ; } public Edge peekMin() // peek at minimum item { return queArray[size-1]; } public int size() // return number of items { return size; } public boolean isEmpty() // true if queue is empty { return (size==0); } public Edge peekN(int n) // peek at item n { return queArray[n]; } public int find(int findDex) // find item with specified { // destVert value for(int j=0; j<size; j++) if(queArray[j].destVert == findDex) return j; return -1; } } // end class PriorityQ //////////////////////////////////////////////////////////////// class Vertex { public char label; // label (e.g. 'A') public boolean isInTree; // - public Vertex(char lab) // constructor { label = lab; isInTree = false; } // - } // end class Vertex //////////////////////////////////////////////////////////////// class Graph { [...]... the minimum distance public int getMin() // get entry from sPath { // with minimum distance int minDist = INFINITY; // assume large minimum int indexMin = 0; for(int j=1; j . inf 80 (via Ajo) inf The entry "inf" is short for "infinity," and means that you can't get from Ajo to the town shown in the. As in the minimum spanning tree algorithm, we're dividing the towns into three categories: 1. Towns in which we've installed an agent; they're in the tree fanciful idea of installing a cable TV system, we've shown the main ideas behind the minimum spanning tree for weighted graphs. Now let's see how we'd go about creating the algorithm