Algorithms in Systems Engineering IE170 Lecture 14 Dr. Ted Ralphs IE170 Lecture 14 1 References for Today's Lecture Required reading CLRS Chapter 22 References R. Sedgewick, Algorithms in C++ (Third Edition), 1998. IE170 Lecture 14 2 Operations on Graphs Last lecture, we saw an algorithm that could be used to analyze the connectivity of a graph without actually storing the graph. In discarding the list of edges, we lose a great deal of information about the structure of the graph. In many cases, we need to make use of that information to perform other operations. What are the basic operations we might want to perform on a graph if we could store it somehow? IE170 Lecture 14 3 Graph Interface Class class Graph{ private: // Implementation dependent code public: Graph(int); ~Graph(); int V() const; int E() const; int insert(Edge e); int delete(Edge e); bool edge(int v, int w) const; Vertex* getFirst(int i); }; IE170 Lecture 14 4 Vertex and Edge Classes class Edge{ public: Edge(int i, int j): v(i), w(j) {} ~Edge(); int v, w; }; class Vertex{ private: // Imlementation dependend code public: int getIndex() const; Vertex const * getNext() const; } IE170 Lecture 14 5 A Client Function for Printing a Graph Here's an example of a standard way in which the graph interface class is used. Here, we print out a graph by enumerating all the edges incident to each vertex. void printGraph(const Graph&amp; G) { for (int s = 0; s &lt; G.V(); s++){ cout &lt;&lt; s &lt;&lt; &quot;:&quot;; for (Vertex* t = G.getFirst(s); t != 0; t = t-&gt;getNext()){ cout &lt;&lt; Vertex-&gt;getIndex() &lt;&lt; &quot;:&quot;; } } } IE170 Lecture 14 6 Graph Data Structures To support these basic graph operations, we need a data structure to store the graph. As with many previous data structures, there are basically two different ways to compactly represent a graph. Ajacency matrix: An implementation based on arrays. <a href="/keyword/adjacency-lists/" >adjacency lists</a> : An implementation based on linked lists. We have to analyze the tradeoffs between these two representations, as we have before. IE170 Lecture 14 7 Adjacency Matrix Implementation Consider an undirected graph G = (V, E). The adjacency matrix A of G is an n n symmetric 0 - 1 matrix constructed as follows: Aij = Aji = 1 if {i, j} E, and 0 otherwise. How do we implement the Graph class using an adjacency matrix? IE170 Lecture 14 8 <a href="/keyword/adjacency-lists/" >adjacency lists</a> Implementation The adjacency list for node i is a linked list of all other nodes adjacent to i in the graph. Note that <a href="/keyword/adjacency-lists/" >adjacency lists</a> do not have to be in any particular order. An adjacency list representation of a graph consists of an adjacency list for each node in the graph. How do we implement the Graph class using an <a href="/keyword/adjacency-lists/" >adjacency lists</a> ? IE170 Lecture 14 9 Comparing the Implementations How does the adjacency list implementation compare to the adjacency matrix implementation? Efficiency of basic operations Memory requirements IE170 Lecture 14 10 Finding a Simple Path We now revisit the question of whether there is a path connecting a given pair of vertices in a graph. Using the operations in the Graph class, we can answer this question directly using a recursive algorithm. We must pass in a vector of bools to track which nodes have been visited. bool SPath(const graph&amp; G, int v, int w, bool* visited) { if (v == w) return true; visited[v] = true; for (Vertex* t = G.getFirst(v); t != 0; t = t-&gt;getNext()) if (!visited[t-&gt;getIndex()]) if (SPath(G, t-&gt;getIndex(), w, visited)) return true; return false; } IE170 Lecture 14 11 Finding a Hamiltonian Path Now let's consider finding a path connecting a given pair of vertices that also visits every other vertex in between (called a Hamiltonian path). We can easily modify our previous algorithm to do this by passing an additional parameter d to track the path length. What is the change in running time? bool HPath(const graph&amp; G, int v, int w, bool* visited, int d) { if (v == w) return (d == 0); visited[v] = true; for (int* t = G.getFirst(v); t != 0; t = t-&gt;getNext()) if (!visited[t-&gt;getIndex()]) if (HPath(G, t-&gt;getIndex(), w, visited, d-1)) return true; visited[v] = false; return false; } IE170 Lecture 14 12 Hard Problems We have just seen an example of two very similar problem, one of which is hard and one of which is easy. In fact, there is no known algorithm for finding a Hamiltonian path that takes less than an exponential number of steps. This is our first example of a problem which is easy to state, but for which no known efficient algorithm exists. Many such problems arise in graph theory and it's difficult to tell which ones are hard and which are easy. Consider the problem of finding an Euler path, which is a path between a pair of vertices that includes every edge exactly once. Does this sound like a hard problem? IE170 Lecture 14 13 Depth-first Search With an algorithm called depth-first search, we can compute the number of connected components of a graph, and label each node with a component number. This allows to answer the question of whether two nodes are in the same connected component in constant time. Here is the basic depth-first search function. void DFS(const graph&amp; G, int v, const int compNum, int* comps) { comps[v] = compNum; for (Vertex* t = G.getFirst(v); t != 0; t = t-&gt;getNext()) if (!comp[t-&gt;getIndex()]) DFS(G, t-&gt;getIndex, compNum, comp) } What is the running time of this algorithm? IE170 Lecture 14 14 Component Labeling To label all vertices with a component number, we simply call DFS iteratively on each vertex that has not been labeled. int Label(const graph&amp; G) { int numComps(0); int *comps(new int[G.V()]); for (int s = 0; s &lt; G.V(); s++) comps[v] = 0; for (int s = 0; s &lt; G.V(); s++){ if (!comps[v]){ numComps++; DFS(G, v, compNum, comp) } } return numComps; } IE170 Lecture 14 15 DFS vs. Union-Find What is the overall running time of the labeling algorithm? How does this compare to union-find? What are the advantages of union-find?