L10 Graphs. Alice E. Fischer. April Alice E. Fischer L10 Graphs... 1/37 April / 37

Size: px

Start display at page:

Download "L10 Graphs. Alice E. Fischer. April Alice E. Fischer L10 Graphs... 1/37 April / 37"

Egbert Stephens
5 years ago
Views:

1 L10 Graphs lice. Fischer pril 2016 lice. Fischer L10 Graphs... 1/37 pril / 37

2 Outline 1 Graphs efinition Graph pplications Graph Representations 2 Graph Implementation 3 Graph lgorithms Sorting Traversal onnectivity lice. Fischer L10 Graphs... 2/37 pril / 37

3 Graphs Graphs efinitions, Terminology, and xamples pplications Graph Representations Topological Sort lgorithm lice. Fischer L10 Graphs... 3/37 pril / 37

4 Graphs efinition What is a Graph? graph is collection of nodes, with labels, often single letters, together with a collection of edges. ach edge connects two nodes. directed graph has edges that go in only one direction (arrows). n undirected graph has bi-directional edges (simple lines). The edges in a graph may be weighted or not. weight represents the cost of moving from one end of the edge to the other. lice. Fischer L10 Graphs... 4/37 pril / 37

5 Graphs efinition irected and Weighted.. or not Undirected, unweighted Weighted irected H G F H G F H G F ndy works with ob 1 hour from nn rbor ill supervises nn ake, and Gina to Grand Rapids harles, and d lice. Fischer L10 Graphs... 5/37 pril / 37

6 Graphs efinition Subgraphs subgraph is any subset of the nodes of a graph, and the edges that connect them. The diagram shows two subgraphs (blue and orange) of an undirected graph. G H F Subgraphs with only one or two outside connections are of interest, especially in applications that involve choosing the location for resources. lice. Fischer L10 Graphs... 6/37 pril / 37

7 Graphs efinition cyclic Graphs have no ycles cycle is a path through the nodes that permits you to walk around and around. This directed graph has two short cycles (red and blue edges) and a longer cycle that goes through H F, and. G H F Many graph problems involve the existence (or absence) of cycles. lice. Fischer L10 Graphs... 7/37 pril / 37

8 Graphs efinition Sources and Sinks In a directed graph, a source is a node with no predecessors, and a sink is a node with no successors. G H F The green node is a source, the red nodes are sinks. lice. Fischer L10 Graphs... 8/37 pril / 37

9 Graphs efinition onnected omponents In some graphs, all components are connected to the others. Here is a graph where that is not true: the blue components are not connected to the pink ones. M K L N Often, it is not obvious that a graph is disconnected. There is an algorithm for finding the connected components in a graph. lice. Fischer L10 Graphs... 9/37 pril / 37

10 Graphs efinition Spanning Tree spanning tree is a tree superimposed upon a graph. This tree uses some, but not all, of the graph s edges, and does not have cycles. spanning tree is minimum if the total weight of all its edges is the total weights of all other spanning trees. If a graph has more than one connected component, then it needs more than one spanning tree to cover it. We call this set a spanning forest. M K L N lice. Fischer L10 Graphs... 10/37 pril / 37

11 Graphs efinition ipartite Graphs have Two Kinds of Nodes special but useful kind of graph has two kinds of nodes, and every edge goes from a node of one kind to an node of the other kind. K L M N lice. Fischer L10 Graphs... 11/37 pril / 37

12 Graphs Graph pplications Graph Problems Many practical and mathematical problems are modeled by graphs The traveling salesman problem. Routes from a warehouse to all the retail stores. Roads and intersections (Google maps). Friend relationships (Faceook). Tasks and subtasks in a construction project. Flow optimization on a network. Placement of caches in a distributed data base. Some graph problems can be solved in a reasonable amount of time (polynomial time), for others (called NP-complete problems), no algorithm exists that is better than try all possibilities. lice. Fischer L10 Graphs... 12/37 pril / 37

13 Graphs Graph Representations Representation of a Graph Two representations are commonly used for graphs: matrices or a list of nodes with lists of adjacent nodes. We look first at the matrix representation, which is appropriate for dense graph (those with many edges). The rows of the matrix represent a node and its outgoing edges. The columns represent the node and its incoming edges. For an unweighted graph, each matrix cell contains a 1 or a 0 saying whether or not the edge is present. For a weighted graph, each matrix cell contains the weight. (Sometimes, is used to indicate a missing edge.) lice. Fischer L10 Graphs... 13/37 pril / 37

14 Graphs Graph Representations Matrix Representation of a Graph The matrix on the left represents an undirected graph with weighted edges. These matrices are always symmetric around the main diagonal. On the right, we represent a directed graph with unweighted edges. The edges are represented by a boolean value (1/0), where only the 1 values are shown. The matrix for a directed graph is not symmetric. lice. Fischer L10 Graphs... 14/37 pril / 37

15 Graphs Graph Representations The djacency List Representation Use this representation for sparse graphs and graphs that can change. ach node has a name and an adjacency list, and may have other associated information. The main data structure is a map of nodes. node is stored in the map with its name, and can later be found by name. n adjacency list is a vector of edges from one node (the fromnode) to other nodes (the tonodes). If the graph is weighted, each edge has a weight as well as a fromnode and a tonode lice. Fischer L10 Graphs... 15/37 pril / 37

left. ompare that to the adjacency list representation on

16 Graphs Graph Representations n Undirected, Weighted Graph The matrix representation of this graph is shown on the left. ompare that to the adjacency list representation on the right. lice. Fischer L10 Graphs... 16/37 pril / 37

17 Graphs Graph Representations irected, Unweighted Graph The matrix representation of this graph is shown on the left. ompare that to the adjacency list representation on the right. lice. Fischer L10 Graphs... 17/37 pril / 37

18 Graph Implementation Graph Implementation djacency List Representation: lasses uilding a Graph The ode lice. Fischer L10 Graphs... 18/37 pril / 37

19 Graph Implementation djacency List Representation: lasses lasses that, together, implement a graph structure: Graph dge Node ontainer templates used: stl::map is used for the set of Nodes, indexed by the node name. stl::vector is used for the adjacency lists. stl::vector is used with the added heap functions for a sorting edges. QueueT is used for breadth-first search. lice. Fischer L10 Graphs... 19/37 pril / 37

20 Graph Implementation What is a Map? We use a map to organize a data set that must be searched often. map is an associative container data structure. You store pairs in the map, where each pair consists of a data object and an indexing key. To retrieve a data object later, you execute find( key ). The programmer can locate an object without writing a search loop. In ++, the map template is implemented efficiently, with O(log(n)) complexity for insertion and search. (Probably a red-black tree). Imagine implementing Google Maps, with hundreds of thousands of cities (nodes). We want the city-nodes stored in an O( log(n) ) container like a balanced tree, not in a O( n ) container like a vector or linked list. lice. Fischer L10 Graphs... 20/37 pril / 37

21 Graph Implementation Making a Map of Nodes We use a map<string, Node> to store the Nodes in our Graph. To use the map, we need an iterator: map<string, Node>::iterator p; We insert pairs of a ++ string and a Node: pair<string, Node> We will input a name and use it OTH in the pair and to call the Node constructor. string name = "Nan"; make_pair( name, Node(name) ); make_pair() makes a pair, then returns a second pair consisting of the pair it made and a boolean success/failure code. To get an iterator pointing to the pair we want, select.first: nodemap.insert(item).first; For simplicity, in this program we ignore the success/failure code. Good practice would be to check it and call fatal() if it is false. lice. Fischer L10 Graphs... 21/37 pril / 37

22 Graph Implementation Using a Map of Nodes We made the map so that we could easily and efficiently find any node in the graph, given its name. To locate a node, use map::find(), which returns an iterator to a pair: map<string, Node>::iterator p; p = nodemap.find(name); If the node was not in the map, find() returns nodemap.end(). if (p == nodemap.end()) { // name not found in map Not found is normal inside the Graph constructor but is a fatal error when it happens in the middle of an algorithm. lice. Fischer L10 Graphs... 22/37 pril / 37

23 Graph Implementation uilding a Graph To build a Graph data structure: Input file, first line, says whether the graph is directed or undirected. Other input lines specify one edge each: names of the fromnode and tonode, and the edge s weight For an unweighted graph, the file should give weight=1 for all edges. When an edge is read, we use its name to find its from and to nodes in the node map. The first time a name is seen, it is inserted into the map. Then the edge is appended to the adjacency list of the fromnode. For undirected graphs, an edge in the opposite direction is added to the adjacency list of the tonode, also. lice. Fischer L10 Graphs... 23/37 pril / 37

24 Graph lgorithms Graph lgorithms Topological Sort epth-first Traversal readth-first Traversal Single-Source Shortest Path (ijkstra) Minimum Spanning Tree (Kruskal) lice. Fischer L10 Graphs... 24/37 pril / 37

25 Graph lgorithms Sorting Topological Sort: for onnected, irected, cyclic Graphs etermine the in-degree of all nodes. t any time, if there is no node with in-degree == 0, the graph has a cycle and cannot be sorted. Repeat this loop until all nodes are in the solution set. hoose any unused node with in-degree 0 and add it to the sorted solution set. Mark it as used. ount it. ecrement the in-degree of every node on its adjacency list. This algorithm is used for planning large multi-part projects. node represents each sub-project. n edge coming into a node represents a prerequisite sub-project. The edges from a node are given weights equal to the time it will take to complete the sub-project. The total weights on the path from the source to the most distant sink is the estimated time to complete the project. lice. Fischer L10 Graphs... 25/37 pril / 37

26 Graph lgorithms Sorting Topological Sort: diagrams G H F NO F G H Indegree Order G F H etails of execution are shown in the file TopSort. lice. Fischer L10 Graphs... 26/37 pril / 37

27 Graph lgorithms Traversal epth-first Traversal iagrams Start with a designated root node and the first node on its adjacency list. Recursively visit all other accessible nodes in the graph in depth-first order. That is, process the root s, first son, grandson, etc. before processing the root s second son, etc. etails are on the next slide. H H G G F F lice. Fischer L10 Graphs... 27/37 pril / 37

28 Graph lgorithms Traversal epth-first Traversal: any Graph Start with a selected root name and find the node in the map: Node* root = nodemap.find(name) Mark this node as used, print it, and set the node counter to 1. all a recursive helper function using the argument root. Iterate through the edges on its adjacency list using an iterator named scan. Let Node* to = scan->tonode. If the to node has already been visited, continue at the top of the loop. Otherwise, process the to-node: mark it as visited, print it. Recursively call the helper function with the to-node and add 1 to the counter returned by the recursive call. Return this count to the caller. If the number of nodes marked does not equal the number in the graph, the graph has more than one component. lice. Fischer L10 Graphs... 28/37 pril / 37

29 Graph lgorithms Traversal readth-first Traversal: any Graph Start with a designated root node. Visit all other accessible nodes in the graph in breadth-first order. That is, visit all the sons of a node before visiting any of the grandsons. Mark each visited node so that you can avoid visiting the same node twice. etails are on the next slide. H H G G F F lice. Fischer L10 Graphs... 29/37 pril / 37

30 Graph lgorithms Traversal readth-first Traversal: any Graph eclare an empty Queue<dge*> named unprocessed. Start with a designated root node. Mark it as used. Print the node and set the node counter to 1. ppend all of the edges on the root s adjacency list to unprocessed. While the node-count is smaller than the number of nodes in the graph, and the unprocessed queue is non-empty, loop: Remove an edge from the queue. all it ed. Let Node* np = ed s tonode. If *np was previously visited, ignore the edge. Otherwise, mark *np visited, count it, print it, and add all of *np s edges to the unprocessed queue. If the number of nodes marked does not equal the number in the graph, the graph has more than one component. lice. Fischer L10 Graphs... 30/37 pril / 37

31 Graph lgorithms Traversal Single-Source Shortest Path (ijkstra): iagrams Start with a designated root node. Find the set of edges that lead to all other accessible nodes with the smallest possible distance between the root node and each other node. etails are on the next 3 slides. H G F H G F lice. Fischer L10 Graphs... 31/37 pril / 37

32 Graph lgorithms Traversal Single-Source Shortest Path: any Graph For this algorithm, we use a priority queue implemented by a minheap data structure. The items in the minheap are FringeItems, a class defined inside Graph for this purpose. FringeItem is a pair of <int, dge>, where the int + the weight of the edge is the priority of the item. Since we are implementing a heap, we need a comparison function that defines the heap order. static bool compare(const dge& e1, const dge& e2) { return e1.weight > e2.weight; } Two typedefs are used to give us short names for the types involved: typedef bool (ompare_t)(const FringeItem&, const FringeItem&); typedef PQueue<FringeItem, ompare_t> SPHeap; lice. Fischer L10 Graphs... 32/37 pril / 37

33 Graph lgorithms Traversal Single-Source Shortest Path: Setup The algorithm: eclare an empty SPHeap of FringeItems named fringe, using Graph::closer() as the comparison function. Start *np = a pointer to the root node. Mark it as used. Print the node and set the node counter to 1. Make a FringeItem out of each edge on the root s adjacency list, using 0 as the first member of the FringeItem. ppend the item to the fringe. While the node-count is smaller than the number of nodes in the graph, and the fringe queue is non-empty, execute the loop on the next slide. When the loop ends, if the number of nodes marked does not equal the number in the graph, the graph has more than one component. lice. Fischer L10 Graphs... 33/37 pril / 37

34 Graph lgorithms Traversal Single-Source Shortest Path: main processing loop Pop a FringeItem from the minheap. all it current: current.first is the cost of going from the root to a particular visited node, current.second is an edge starting at that node. ecause we are using a minheap, this pair represents the cheapest way to get from the root to an unvisited node. urrent is a pair, where current.second is an dge. Let Node* np = current.second.tonode. If *np was previously visited, ignore the current edge. Otherwise, mark as visited, count it and print it. Set the weight of *np to current.first (an int). This represents the cost of getting to *np using the edge current.second. For each edge on *np s adjacency-list, make a FringeItem using the sum of the edge s weight and *np s weight. Insert the new FringeItem into the fringe. lice. Fischer L10 Graphs... 34/37 pril / 37

35 Graph lgorithms onnectivity Minimum Spanning Tree (Kruskal): Weighted Graphs Find the set of edges that connect the nodes with the least total distance. This algorithm finds the connected components of the graph. H G F H G F etails of execution are shown in the file SpanningTree; the algorithm is summarized on the next 2 slides. lice. Fischer L10 Graphs... 35/37 pril / 37

36 Graph lgorithms onnectivity Minimum Spanning Tree (Kruskal): Setup This algorithm uses a minheap of dges to select the unused edge with minimum cost. Initialize the heap to contain all the edges in the graph. We will use two extra members in the Node class: a Node* called parent and a weight. Initialize them to NULL and 0. While the node-count is smaller than the number of nodes in the graph, and the fringe queue is non-empty, execute the loop on the next slide. When the loop ends, we have constructed a spanning forest. ach node with a NULL parent represents the nodes in a connected subgraph that is disconnected from the rest of the graph. lice. Fischer L10 Graphs... 36/37 pril / 37

37 Graph lgorithms onnectivity Minimum Spanning Tree (Kruskal): main processing loop Let dge current = the minimum edge popped off the minheap. While current.tonode->parent is non-null, walk up the chain of parent links. When you come to a Node with a NULL parent, it represents the component that the tonode is in. Now do the same thing with the fromnode of current. If the result is the same as the tonode, these nodes are both in the same component. iscard the link that connects them. Otherwise, add the edge to the solution set, count it, print it, add its weight to the total weight of the solution Then set the parent pointer of either the tonode or the fromnode to the other one. Set the pointer of the lighter weight node to point at the heavier weight node. This keeps the tree more balanced. lice. Fischer L10 Graphs... 37/37 pril / 37

Introduction to Graphs. common/notes/ppt/

Introduction to Graphs. common/notes/ppt/ Introduction to Graphs http://people.cs.clemson.edu/~pargas/courses/cs212/ common/notes/ppt/ Introduction Graphs are a generalization of trees Nodes or verticies Edges or arcs Two kinds of graphs irected