Graphs

Definition of a graph

Precisely stated, a (directed) graph is

1. a set, N, of nodes
2. a set, E, of pairs of elements from N, called edges.

N = { KC, Chi, Dal, NYC }
E = { (Dal,KC), (KC,Chi), (Chi,KC), (Chi,Dal), (Dal,Chi), (Chi,NYC)}

A path from a node A to node B is a sequence of zero or more edges that start at A, connect together, and end at B. In the example, there is a path from Dal to NYC but there is no path from NYC to Dal.

Notice that a tree is a special form of graph, where one node is called the root, and there is exactly one path from the root to all the other nodes. Unlike a tree, a graph can have multiple paths between nodes, and a graph can have cycles (loops), where a path can go from a starting node to other nodes and back to the starting node again.

Another form of graph is an undirected graph, where every edge from a node A to node B is read also as an edge from B to A. We draw an undirected graph without arrowheads on the edges, like this:

A graph is a weighted graph if some form of label or value (called a ``weight'') is attached to each of its edges. For example, mileages might be attached to the directed graph seen first,

N = { KC, Chi, Dal, NYC }
E = { (Dal,600,KC), (KC,500,Chi), (Chi,500,KC), (Chi,800,Dal), (Dal,800,Chi), (Chi,900,NYC)}

Representing graphs in a computer

There are two standard ways of storing graphs in a computer: the adjacency matrix and the adjacency list.

An adjacency matrix is a kind of ``mileage table'':

        Chi  Dal  KC  NYC
       +-----------------
Chi    |  0  800  500 900
       |
Dal    |800    0  600  -1
       |
KC     |500   -1    0  -1
       |
NYC    | -1   -1   -1   0

The adjacency list organizes the graph's edges into sets, based on the edges' sources. Here is the adjacency list for the example:

As a rule, use an adjacency matrix to store a graph where there are edges between almost all the nodes; use an adjacency list when the graph has few edges, that is, it is sparse, that is, there are fewer than N * log₂ N edges, for a graph with N nodes.

The adjacency matrix and adjacency list are ``raw'' forms of graph and are not oriented towards solving any particular problem. The forms of problems that one must solve are typically:

• process/print the nodes, e.g., check if the graph is connected --- for every node, one can go to all other nodes
• process/print the edges, e.g., find the shortest, weighted path from one node to another

Spanning trees

A spanning tree is a tree that lists all the nodes in a graph but not necessarily all the edges. Its root is the ``entry node'' into the graph. Here are spanning trees that we can generate from the example directed graph where we use Dal as the entry node. For simplicity, we omit the weights on the edges, since spanning trees are normally used to answer questions about the nodes.

Regular trees

A regular tree is a tree that generates all the paths that can be taken starting from an entry node, where along every path, no node repeats. Here is the regular tree that generates all paths from entry node, KC:

We now examine two standard and classic graph problems and show how to use the trees to solve them.

Application: modelling sets by spanning trees --- UNION-FIND

A collection of graph nodes is connected if for every node in the collection, there is a path to every other node in the collection. For this (undirected) graph:

The collections are disjoint ``sets,'' and such sets play a crucial role in answering questions of the form: ``Is there a path from node A to node B?'' or ``Do A and B belong to the same set?'' To answer the question, we check if A and B are in the same connected collection.

To answer such questions, it is useful to maintain spanning trees that include all the nodes of the graph. For the example, two spanning trees are required, one for each ``set'':

Another view is that each set is named by the root of its spanning tree --- in the example, we have the Tokyo set and the KC set. Then, the questions just asked are set-membership questions: ``Is Dal in the KC-set''?

The previous checks of ``connectivity'' take time O(log₂N), where N is the number of nodes in the graph (assuming that we can locate the source and destination nodes in fixed time, which we can do if we save the addresses of all the spanning-tree nodes in a hash table or spelling tree).

The operation is called a FIND operation. There is also a UNION operation, which corresponds to unioning together two sets:

Say that flights are added between Chi and Osaka, that is, an edge has been added between these two nodes. How can we efficiently combine the spanning trees to reflect the new graph edge?

There is a simple solution to updating the spanning trees: draw a line between Chi's root and Osaka's:

One drawback of the simple definition of UNION is that it can create unbalanced spanning trees --- the above tree is not height-balanced. One way to improve UNION is to link the spanning tree with fewer nodes to the one with more nodes. For the above example, this would cause Tokyo's tree to link to KC's, which gives a slightly better balance.

But we can do better: the FIND operation is often improved so that it rebalances a spanning tree after it finds a path from a node in the spanning tree to its root --- each time a FIND operation is performed, all the nodes traversed on the path to the root are attached directly to the root. For the above example, a FIND operation on NYC would cause both NYC and Chi to be relinked directly to the root, Tokyo:

         Tokyo
  /     /   |   \    \
Seoul Osaka KC  Chi  NYC
            |
            Dal

Application: finding the shortest path --- Dijkstra's algorithm

A naive solution would enumerate all possible paths from Dal to NYC, say by using a stack and depth-first search, starting from ``root node'' Dal. But there is a smarter, faster solution, due to Dijkstra, which constructs a regular tree that enumerates only the ``short'' paths.

The key idea behind Dijkstra's algorithm is: generate a regular tree whose root is the start node; generate all possible paths from the root, but stop a path if either

1. the next node in the path is one that has already appeared in the path (this signifies the path has entered a loop and is not the shortest solution; it is the usual criterion for stopping a path in a regular tree)
2. the next node is the destination node (and so we calculate the weight of the path from the root to the destination and see if it is the least we have seen so far)
3. the next node is a node that we have already reached in some other path in the tree and the weight of the other path is already less-than-or-equal-to the weight of the path we are just now constructing --- this means the path we are just now constructing cannot be the shortest path

Here is an example --- say we want the shortest path from Dal to NYC in the graph just seen. We begin with this this array and initial regular tree:

           Dal  Chi   KC  NYC
          +----+----+----+----+
shortest: |   0|   ?|   ?|   ?|
          +----+----+----+----+

The array notes that the shortest path from Dal to Dal is 0; the other distances are undetermined at this time.

The edges from Dal generate this slightly larger regular tree and update the array to read

           Dal  Chi   KC  NYC
          +----+----+----+----+
shortest: |   0| 800| 600|   ?|
          +----+----+----+----+

When we develop Chi, we find three edges: the first, to KC is to a node that has been seen before. The array tells us that the path found earlier to KC had weight 600, so the current path, which has weight 800+500 = 1300, is not least and can be terminated. The next edge leads to to Dal and a repeat of a node already seen on this path, so there is no way that this path can be shortest; we terminate this path. The third edge goes from Chi to NYC, and we update the array with our discovery:

           Dal  Chi   KC  NYC
          +----+----+----+----+
shortest: |   0| 800| 600|1700|
          +----+----+----+----+

At this point, all paths in the regular tree are completely developed, and we quit --- the shortest path goes from Dal to Chi to NYC.

Finally, we note that, in the previous example, the regular tree itself need not be explicitly constructed in computer storage. Instead, we keep a second array that remembers the edges that yielded the shortest path. Here is the example repeated, with the two arrays, one that remembers the weights and one that remembers the individual edges in the shortest path that we build:

           Dal  Chi   KC  NYC
          +----+----+----+----+
shortest: |   0|   ?|   ?|   ?|
          +----+----+----+----+

	  Dal  Chi   KC  NYC
	 +----+----+----+----+
previous:|null|   ?|   ?|   ?|
	 +----+----+----+----+

           Dal  Chi   KC  NYC
	  +----+----+----+----+
shortest: |   0| 800| 600|   ?|
          +----+----+----+----+

	   Dal  Chi   KC  NYC
          +----+----+----+----+
previous: |null| Dal| Dal|   ?|
          +----+----+----+----+

After the attempted moves from KC, there are no change to the arrays. The move from Chi to NYC gives the answer and the last edge in the shortest path:

           Dal  Chi   KC  NYC
	  +----+----+----+----+
shortest: |   0| 800| 600|1700|
          +----+----+----+----+

	   Dal  Chi   KC  NYC
          +----+----+----+----+
previous: |null| Dal| Dal| Chi|
          +----+----+----+----+

Indeed, we can assemble the path from the edges, listed in reverse: NYC-Chi-Dal (null).