# Computational Optimization ISE 407. Lecture 19. Dr. Ted Ralphs

Size: px
Start display at page:

## Transcription

1 Computational Optimization ISE 407 Lecture 19 Dr. Ted Ralphs

2 ISE 407 Lecture 19 1 Search Algorithms Search algorithms are fundamental techniques applied to solve a wide range of optimization problems. Search algorithms attempt to find all the nodes in a network satisfying a particular property. Examples Find nodes that are reachable by directed paths from a source node. Find nodes that can reach a specific node along directed paths Identify the connected components of a network Identify directed cycles in network Let us consider undirected graphs to start. We will first consider an algorithm for finding a simple path in a graph.

3 ISE 407 Lecture 19 2 Connectivity in Graphs An undirected graph is said to be connected if there is a path between any two vertices in the graph. A graph that is not connected consists of a set of connected components that are the maximal connected subgraphs. Given a graph, one of the most basic questions one can ask is whether vertices i and j are in the same component. In other words, is there a path from i to j? Such questions might arise in many applications.

4 ISE 407 Lecture 19 3 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 of whether there is a path from i to j using a recursive algorithm. We must pass in a vector of bools to track which nodes have been visited. def SPath(G, v, w, visited = {}) if v == w: return True visited[v] = True for n in v.get_neighbors(): if not visited[n]: if SPath(G, n, w, visited): return True return False

5 ISE 407 Lecture 19 4 Labeling Components The set of all nodes connected to a given node by a path is called a component. How easy is it to determine all of the nodes in the same component as a given node? def DFSRecursion(G, v, pred, component_num = 0): G.set_node_attr(v, component, component_num) for n in G.get_neighbors(v): if G.get_node_attr(n, component ) == None pred[n] = v DFS(G, n, pred, component_num) return def DFS(G, v, component_num = 0) for n in G.get_node_list(): G.set_node_attr(n, component, None) DFSRecursion(G, v, [], component_num) return

6 ISE 407 Lecture 19 5 Depth-first Search for General Graphs The algorithm we have just seen is a generalization of the depth-first search method we saw earlier for trees. We will see why it is called this shortly. Associated with the search is a search tree that can be used to visualize the algorithm. At the time a node n is discovered, we can record v as its predecesor. The set of edges consisting of each node and its predecessor forms a tree rooted at v. We call the edges in the tree tree edges. The remaining edges connect a vertex with an ancestor in the tree that is not its parent and are called back edges. Why must every edge be either a tree edge or a back edge?

7 ISE 407 Lecture 19 6 Complexity of Depth-first Search How do we analyze a DFS algorithm? How many recursive calls are there? How does the graph data structure affect the running time? Adjacency matrix Adjacency list

8 ISE 407 Lecture 19 7 Node Ordering As in depth-first search for trees, the nodes can be ordered in two ways. Preorder: The order in which the nodes are first discovered (discovery time). Postorder: The order in which the nodes finished (the recursive calls on all neighbors return). These orders will be referred to in various algorithms we ll study.

9 ISE 407 Lecture 19 8 Labeling All Components To label all components, we loop through all the nodes in the graph and start labeling the component of any node we find that has not already been labeled. def label_component(g): component_num = 0 for n in G.get_node_list(): G.set_node_attr(n, component, None) for n in G.get_node_list(): if G.get_node_attr(n, component ) is None: DFS(G, n, component_num) component_num += 1 return What is the complexity of this algorithm?

10 ISE 407 Lecture 19 9 Depth-first Search in Directed Graphs DFS in a directed graph is very similar to DFS in an undirected graph. The main difference is that each arc is only encountered once during the search. Also, note that the notion of a component is different here. def DFSRecursion(G, v, pred): G.set_node_attr(v, color, green ) for n in G.get_neighbors(v): if G.get_node_attr(n, color ) == red pred[n] = v DFS(G, n, pred) return def DFS(G, v) for n in G.get_node_list(): G.set_node_attr(n, color, red ) DFSRecursion(G, v, []) return What nodes will this search reach?

11 ISE 407 Lecture Depth-first Search in Directed Graphs As with undirected graphs, DFS in directed graphs produces a search tree that is directed out from the initial node (an out tree). At the time a node n is discovered, we record v as its predecesor. The set of arcss consisting of each node and its predecessor forms a tree rooted at v. We call the arcs in the tree tree arcs. The remaining arcs can be either Back arcs: Those connecting a vertex to an ancestor Down arcs: Those connecting a vertex to a descendant Cross arcs: Those connecting a vertex to a vertex that is neither a descendant nor an ancestor.

12 ISE 407 Lecture Node Order and Arc Type Also as with undirected graphs, we can order the nodes in two different ways: postorder and preorder. As before, we refer to the preorder number of a node as its discovery time and the postorder number as its finishing time. We can identify the type of an arc as follows. It is a back arc if it leads to a node with a later finishing time. Otherwise, it is a cross arc if it leads to a node with an earlier discovery time and a down arc if it leads to a node with a later discovery time.

13 ISE 407 Lecture Problems Solvable With DFS (Undirected Graphs) Cycle Detection: The discovery of a back edge indicates the existence of a cycle. Simple Path Connectivity Component Labeling Spanning Forest Two-colorability, bipartiteness, odd cycle

14 ISE 407 Lecture General Graph Search Depth-first search is so called because the node selected in each step is a neighbor of the node that is farthest from the root (in the tree). This is convenient because it allows a simple recursive implementation. Could we search the graph in a different order?

15 ISE 407 Lecture General Graph Search Algorithm def search(self, root, q = Stack()): if display == None: display = self.display_mode if isinstance(q, Queue): addtoq = q.enqueue removefromq = q.dequeue elif isinstance(q, Stack): addtoq = q.push removefromq = q.pop visited = {} addtoq(root) while not q.isempty(): current = removefromq() self.process_node(current, q) for n in current.get_neighbors(): if not n in visited: visited[n] = True self.process_edge(current, n) addtoq(n)

16 ISE 407 Lecture General Search Algorithm The algorithm is a template for a whole class of algorithms. If Q is a stack (LIFO), we are doing depth-first search, as before. If Q is a queue (FIFO), we are doing breadth-first search. In other cases, we will want to maintain Q as a priority queue. What problem does breadth-first search of a graph solve?

17 ISE 407 Lecture Complexity of Search Algorithm The search proceeds differently depending on which element v is selected from q in each iteration. q must be ordered in some way by storing it in an appropriate data structure. If q is a queue, elements are inserted at one end and removed from the other and we get FIFO ordering. If q is a stack, elements are inserted and deleted from the the same end and we get LIFO ordering. The efficiency of the algorithm can be affected by the data structure used to maintain q, what additional steps are required in process node, and what additional steps are required in process edge.

18 ISE 407 Lecture Aside: 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?

19 ISE 407 Lecture Aside: Finding a Hamiltonian Path (code) def HPath(G, v, w = None, d = None, visited = {}) if d == None: d = G.get_node_num() if v == w: return d == 0 if w == None: w = v visited[v] = True for n in v.get_neighbors(): if not visited[n]: if SPath(G, n, w, d-1, visited): return True visited[v] = False return False

20 ISE 407 Lecture Aside: 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?

### Trees : Part 1. Section 4.1. Theory and Terminology. A Tree? A Tree? Theory and Terminology. Theory and Terminology

Trees : Part Section. () (2) Preorder, Postorder and Levelorder Traversals Definition: A tree is a connected graph with no cycles Consequences: Between any two vertices, there is exactly one unique path

### LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS

Department of Computer Science University of Babylon LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS By Faculty of Science for Women( SCIW), University of Babylon, Iraq Samaher@uobabylon.edu.iq

### Trees. Tree Structure Binary Tree Tree Traversals

Trees Tree Structure Binary Tree Tree Traversals The Tree Structure Consists of nodes and edges that organize data in a hierarchical fashion. nodes store the data elements. edges connect the nodes. The

### Graph. Vertex. edge. Directed Graph. Undirected Graph

Module : Graphs Dr. Natarajan Meghanathan Professor of Computer Science Jackson State University Jackson, MS E-mail: natarajan.meghanathan@jsums.edu Graph Graph is a data structure that is a collection

### CS 310 Advanced Data Structures and Algorithms

CS 31 Advanced Data Structures and Algorithms Graphs July 18, 17 Tong Wang UMass Boston CS 31 July 18, 17 1 / 4 Graph Definitions Graph a mathematical construction that describes objects and relations

### Data Structure. IBPS SO (IT- Officer) Exam 2017

Data Structure IBPS SO (IT- Officer) Exam 2017 Data Structure: In computer science, a data structure is a way of storing and organizing data in a computer s memory so that it can be used efficiently. Data

### Undirected Graphs. Hwansoo Han

Undirected Graphs Hwansoo Han Definitions Undirected graph (simply graph) G = (V, E) V : set of vertexes (vertices, nodes, points) E : set of edges (lines) An edge is an unordered pair Edge (v, w) = (w,

### Elementary Graph Algorithms CSE 6331

Elementary Graph Algorithms CSE 6331 Reading Assignment: Chapter 22 1 Basic Depth-First Search Algorithm procedure Search(G = (V, E)) // Assume V = {1, 2,..., n} // // global array visited[1..n] // visited[1..n]

### Computational Optimization ISE 407. Lecture 16. Dr. Ted Ralphs

Computational Optimization ISE 407 Lecture 16 Dr. Ted Ralphs ISE 407 Lecture 16 1 References for Today s Lecture Required reading Sections 6.5-6.7 References CLRS Chapter 22 R. Sedgewick, Algorithms in

### Algorithms: Lecture 10. Chalmers University of Technology

Algorithms: Lecture 10 Chalmers University of Technology Today s Topics Basic Definitions Path, Cycle, Tree, Connectivity, etc. Graph Traversal Depth First Search Breadth First Search Testing Bipartatiness

### Lecture 3: Graphs and flows

Chapter 3 Lecture 3: Graphs and flows Graphs: a useful combinatorial structure. Definitions: graph, directed and undirected graph, edge as ordered pair, path, cycle, connected graph, strongly connected

### Design and Analysis of Algorithms

CSE, Winter 8 Design and Analysis of Algorithms Lecture : Graphs, DFS (Undirected, Directed), DAGs Class URL: http://vlsicad.ucsd.edu/courses/cse-w8/ Graphs Internet topology Graphs Gene-gene interactions

### Graph Algorithms Using Depth First Search

Graph Algorithms Using Depth First Search Analysis of Algorithms Week 8, Lecture 1 Prepared by John Reif, Ph.D. Distinguished Professor of Computer Science Duke University Graph Algorithms Using Depth

### Data Structures. Elementary Graph Algorithms BFS, DFS & Topological Sort

Data Structures Elementary Graph Algorithms BFS, DFS & Topological Sort 1 Graphs A graph, G = (V, E), consists of two sets: V is a finite non-empty set of vertices. E is a set of pairs of vertices, called

### This course is intended for 3rd and/or 4th year undergraduate majors in Computer Science.

Lecture 9 Graphs This course is intended for 3rd and/or 4th year undergraduate majors in Computer Science. You need to be familiar with the design and use of basic data structures such as Lists, Stacks,

### DS UNIT 4. Matoshri College of Engineering and Research Center Nasik Department of Computer Engineering Discrete Structutre UNIT - IV

Sr.No. Question Option A Option B Option C Option D 1 2 3 4 5 6 Class : S.E.Comp Which one of the following is the example of non linear data structure Let A be an adjacency matrix of a graph G. The ij

### Search Algorithms. IE 496 Lecture 17

Search Algorithms IE 496 Lecture 17 Reading for This Lecture Primary Horowitz and Sahni, Chapter 8 Basic Search Algorithms Search Algorithms Search algorithms are fundamental techniques applied to solve

### Graph Algorithms. Chapter 22. CPTR 430 Algorithms Graph Algorithms 1

Graph Algorithms Chapter 22 CPTR 430 Algorithms Graph Algorithms Why Study Graph Algorithms? Mathematical graphs seem to be relatively specialized and abstract Why spend so much time and effort on algorithms

### Copyright 2000, Kevin Wayne 1

Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. Directed

### Homework 5: Graphs, Minimum Spanning Trees, and Dijkstra Shortest-Path

Homework 5: Graphs, Minimum Spanning Trees, and Dijkstra Shortest-Path 1. (4 points) A graph is Hamiltonian if there is a cycle in the graph visiting each vertex exactly once. Give an example of an Eulerian

### Graphs. Graph G = (V, E) Types of graphs E = O( V 2 ) V = set of vertices E = set of edges (V V)

Graph Algorithms Graphs Graph G = (V, E) V = set of vertices E = set of edges (V V) Types of graphs Undirected: edge (u, v) = (v, u); for all v, (v, v) E (No self loops.) Directed: (u, v) is edge from

### CS490: Problem Solving in Computer Science Lecture 6: Introductory Graph Theory

CS490: Problem Solving in Computer Science Lecture 6: Introductory Graph Theory Dustin Tseng Mike Li Wednesday January 16, 2006 Dustin Tseng Mike Li: CS490: Problem Solving in Computer Science, Lecture

UNIT IV -NON-LINEAR DATA STRUCTURES 4.1 Trees TREE: A tree is a finite set of one or more nodes such that there is a specially designated node called the Root, and zero or more non empty sub trees T1,

### CS 270 Algorithms. Oliver Kullmann. Breadth-first search. Analysing BFS. Depth-first. search. Analysing DFS. Dags and topological sorting.

Week 5 General remarks and 2 We consider the simplest graph- algorithm, breadth-first (). We apply to compute shortest paths. Then we consider the second main graph- algorithm, depth-first (). And we consider

### Computer Science & Engineering 423/823 Design and Analysis of Algorithms

s of s Computer Science & Engineering 423/823 Design and Analysis of Lecture 03 (Chapter 22) Stephen Scott (Adapted from Vinodchandran N. Variyam) 1 / 29 s of s s are abstract data types that are applicable

### Name CPTR246 Spring '17 (100 total points) Exam 3

Name CPTR246 Spring '17 (100 total points) Exam 3 1. Linked Lists Consider the following linked list of integers (sorted from lowest to highest) and the changes described. Make the necessary changes in

### Deﬁnition Example Solution

Section 11.4 Spanning Trees Definition: Let G be a simple graph. A spanning tree of G is a subgraph of G that is a tree containing every vertex of G. Example: Find the spanning tree of this simple graph:

### DHANALAKSHMI COLLEGE OF ENGINEERING, CHENNAI. Department of Computer Science and Engineering CS6301 PROGRAMMING DATA STRUCTURES II

DHANALAKSHMI COLLEGE OF ENGINEERING, CHENNAI Department of Computer Science and Engineering CS6301 PROGRAMMING DATA STRUCTURES II Anna University 2 & 16 Mark Questions & Answers Year / Semester: II / III

### Taking Stock. IE170: Algorithms in Systems Engineering: Lecture 17. Depth-First Search. DFS (Initialize and Go) Last Time Depth-First Search

Taking Stock IE170: Algorithms in Systems Engineering: Lecture 17 Jeff Linderoth Department of Industrial and Systems Engineering Lehigh University March 2, 2007 Last Time Depth-First Search This Time:

### Graph Representation

Graph Representation Adjacency list representation of G = (V, E) An array of V lists, one for each vertex in V Each list Adj[u] contains all the vertices v such that there is an edge between u and v Adj[u]

### Algorithms (VII) Yijia Chen Shanghai Jiaotong University

Algorithms (VII) Yijia Chen Shanghai Jiaotong University Review of the Previous Lecture Depth-first search in undirected graphs Exploring graphs explore(g, v) Input: G = (V, E) is a graph; v V Output:

### Algorithms in Systems Engineering ISE 172. Lecture 16. Dr. Ted Ralphs

Algorithms in Systems Engineering ISE 172 Lecture 16 Dr. Ted Ralphs ISE 172 Lecture 16 1 References for Today s Lecture Required reading Sections 6.5-6.7 References CLRS Chapter 22 R. Sedgewick, Algorithms

### Depth-first search in undirected graphs What parts of the graph are reachable from a given vertex?

Why graphs? Chapter 3. Decompositions of graphs Awiderangeofproblemscanbeexpressedwithclarityandprecisionin the concise pictorial language of graphs. Graph coloring. Graph connectivity and reachability.

### Graph: representation and traversal

Graph: representation and traversal CISC4080, Computer Algorithms CIS, Fordham Univ. Instructor: X. Zhang! Acknowledgement The set of slides have use materials from the following resources Slides for textbook

### Algorithms (VII) Yijia Chen Shanghai Jiaotong University

Algorithms (VII) Yijia Chen Shanghai Jiaotong University Review of the Previous Lecture Depth-first search in undirected graphs Exploring graphs explore(g, v) Input: G = (V, E) is a graph; v V Output:

### Searching in Graphs (cut points)

0 November, 0 Breath First Search (BFS) in Graphs In BFS algorithm we visit the verices level by level. The BFS algorithm creates a tree with root s. Once a node v is discovered by BFS algorithm we put

### Tutorial. Question There are no forward edges. 4. For each back edge u, v, we have 0 d[v] d[u].

Tutorial Question 1 A depth-first forest classifies the edges of a graph into tree, back, forward, and cross edges. A breadth-first tree can also be used to classify the edges reachable from the source

### Graph Algorithms: Chapters Part 1: Introductory graph concepts

UMass Lowell Computer Science 91.503 Algorithms Dr. Haim Levkowitz Fall, 2007 Graph Algorithms: Chapters 22-25 Part 1: Introductory graph concepts 1 91.404 Graph Review Elementary Graph Algorithms Minimum

### Graph representation

Graph Algorithms 1 Graph representation Given graph G = (V, E). May be either directed or undirected. Two common ways to represent for algorithms: 1. Adjacency lists. 2. Adjacency matrix. When expressing

### Representations of Graphs

ELEMENTARY GRAPH ALGORITHMS -- CS-5321 Presentation -- I am Nishit Kapadia Representations of Graphs There are two standard ways: A collection of adjacency lists - they provide a compact way to represent

### CSC Intro to Intelligent Robotics, Spring Graphs

CSC 445 - Intro to Intelligent Robotics, Spring 2018 Graphs Graphs Definition: A graph G = (V, E) consists of a nonempty set V of vertices (or nodes) and a set E of edges. Each edge has either one or two

### (Refer Slide Time: 02.06)

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture 27 Depth First Search (DFS) Today we are going to be talking

### CS2 Algorithms and Data Structures Note 9

CS2 Algorithms and Data Structures Note 9 Graphs The remaining three lectures of the Algorithms and Data Structures thread will be devoted to graph algorithms. 9.1 Directed and Undirected Graphs A graph

Chapter 14 Graphs 2011 Pearson Addison-Wesley. All rights reserved 14 A-1 Terminology G = {V, E} A graph G consists of two sets A set V of vertices, or nodes A set E of edges A subgraph Consists of a subset

### March 20/2003 Jayakanth Srinivasan,

Definition : A simple graph G = (V, E) consists of V, a nonempty set of vertices, and E, a set of unordered pairs of distinct elements of V called edges. Definition : In a multigraph G = (V, E) two or

### Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 5 Exploring graphs Adam Smith 9/5/2008 A. Smith; based on slides by E. Demaine, C. Leiserson, S. Raskhodnikova, K. Wayne Puzzles Suppose an undirected graph G is connected.

### CS 270 Algorithms. Oliver Kullmann. Analysing BFS. Depth-first search. Analysing DFS. Dags and topological sorting.

General remarks Week 5 2 We finish, by analysing it. Then we consider the second main graph- algorithm, depth-first (). And we consider one application of, of graphs. Reading from CLRS for week 5 Chapter

### Graphs and Network Flows ISE 411. Lecture 7. Dr. Ted Ralphs

Graphs and Network Flows ISE 411 Lecture 7 Dr. Ted Ralphs ISE 411 Lecture 7 1 References for Today s Lecture Required reading Chapter 20 References AMO Chapter 13 CLRS Chapter 23 ISE 411 Lecture 7 2 Minimum

### Elementary Graph Algorithms. Ref: Chapter 22 of the text by Cormen et al. Representing a graph:

Elementary Graph Algorithms Ref: Chapter 22 of the text by Cormen et al. Representing a graph: Graph G(V, E): V set of nodes (vertices); E set of edges. Notation: n = V and m = E. (Vertices are numbered

### Trees Algorhyme by Radia Perlman

Algorhyme by Radia Perlman I think that I shall never see A graph more lovely than a tree. A tree whose crucial property Is loop-free connectivity. A tree which must be sure to span. So packets can reach

### Chapter 22 Elementary Graph Algorithms

Chapter 22 Elementary Graph Algorithms Graph Representations Graph G = (V,E) Directed Undirected Adjacency Lists Adjacency Matrix Graph Representations Adjacency List: Undirected Memory: Adjacency: Graph

### Graph Algorithms. Andreas Klappenecker. [based on slides by Prof. Welch]

Graph Algorithms Andreas Klappenecker [based on slides by Prof. Welch] 1 Directed Graphs Let V be a finite set and E a binary relation on V, that is, E VxV. Then the pair G=(V,E) is called a directed graph.

### LECTURE 17 GRAPH TRAVERSALS

DATA STRUCTURES AND ALGORITHMS LECTURE 17 GRAPH TRAVERSALS IMRAN IHSAN ASSISTANT PROFESSOR AIR UNIVERSITY, ISLAMABAD STRATEGIES Traversals of graphs are also called searches We can use either breadth-first

### I A graph is a mathematical structure consisting of a set of. I Formally: G =(V, E), where V is a set and E V V.

Directed and Undirected Graphs Inf 2B: Graphs, BFS, DFS Kyriakos Kalorkoti School of Informatics University of Edinburgh I A graph is a mathematical structure consisting of a set of vertices and a set

### DFS & STRONGLY CONNECTED COMPONENTS

DFS & STRONGLY CONNECTED COMPONENTS CS 4407 Search Tree Breadth-First Search (BFS) Depth-First Search (DFS) Depth-First Search (DFS) u d[u]: when u is discovered f[u]: when searching adj of u is finished

### implementing the breadth-first search algorithm implementing the depth-first search algorithm

Graph Traversals 1 Graph Traversals representing graphs adjacency matrices and adjacency lists 2 Implementing the Breadth-First and Depth-First Search Algorithms implementing the breadth-first search algorithm

### First Semester - Question Bank Department of Computer Science Advanced Data Structures and Algorithms...

First Semester - Question Bank Department of Computer Science Advanced Data Structures and Algorithms.... Q1) What are some of the applications for the tree data structure? Q2) There are 8, 15, 13, and

### 22.3 Depth First Search

22.3 Depth First Search Depth-First Search(DFS) always visits a neighbour of the most recently visited vertex with an unvisited neighbour. This means the search moves forward when possible, and only backtracks

### Inf 2B: Graphs, BFS, DFS

Inf 2B: Graphs, BFS, DFS Kyriakos Kalorkoti School of Informatics University of Edinburgh Directed and Undirected Graphs I A graph is a mathematical structure consisting of a set of vertices and a set

### Graphs. Part I: Basic algorithms. Laura Toma Algorithms (csci2200), Bowdoin College

Laura Toma Algorithms (csci2200), Bowdoin College Undirected graphs Concepts: connectivity, connected components paths (undirected) cycles Basic problems, given undirected graph G: is G connected how many

### Data Structures and Algorithms. Chapter 7. Graphs

1 Data Structures and Algorithms Chapter 7 Werner Nutt 2 Acknowledgments The course follows the book Introduction to Algorithms, by Cormen, Leiserson, Rivest and Stein, MIT Press [CLRST]. Many examples

### Design and Analysis of Algorithms

Design and Analysis of Algorithms CS 5311 Lecture 19 Topological Sort Junzhou Huang, Ph.D. Department of Computer Science and ngineering CS5311 Design and Analysis of Algorithms 1 Topological Sort Want

### 11/22/2016. Chapter 9 Graph Algorithms. Introduction. Definitions. Definitions. Definitions. Definitions

Introduction Chapter 9 Graph Algorithms graph theory useful in practice represent many real-life problems can be slow if not careful with data structures 2 Definitions an undirected graph G = (V, E) is

### Chapter 9 Graph Algorithms

Chapter 9 Graph Algorithms 2 Introduction graph theory useful in practice represent many real-life problems can be slow if not careful with data structures 3 Definitions an undirected graph G = (V, E)

### CSI 604 Elementary Graph Algorithms

CSI 604 Elementary Graph Algorithms Ref: Chapter 22 of the text by Cormen et al. (Second edition) 1 / 25 Graphs: Basic Definitions Undirected Graph G(V, E): V is set of nodes (or vertices) and E is the

### The ADT priority queue Orders its items by a priority value The first item removed is the one having the highest priority value

The ADT priority queue Orders its items by a priority value The first item removed is the one having the highest priority value 1 Possible implementations Sorted linear implementations o Appropriate if

### Elementary Graph Algorithms

Elementary Graph Algorithms Graphs Graph G = (V, E)» V = set of vertices» E = set of edges (V V) Types of graphs» Undirected: edge (u, v) = (v, u); for all v, (v, v) E (No self loops.)» Directed: (u, v)

### Some Extra Information on Graph Search

Some Extra Information on Graph Search David Kempe December 5, 203 We have given basic definitions of graphs earlier in class, and talked about how to implement them. We had also already mentioned paths,

### 12/5/17. trees. CS 220: Discrete Structures and their Applications. Trees Chapter 11 in zybooks. rooted trees. rooted trees

trees CS 220: Discrete Structures and their Applications A tree is an undirected graph that is connected and has no cycles. Trees Chapter 11 in zybooks rooted trees Rooted trees. Given a tree T, choose

### 2. True or false: even though BFS and DFS have the same space complexity, they do not always have the same worst case asymptotic time complexity.

1. T F: Consider a directed graph G = (V, E) and a vertex s V. Suppose that for all v V, there exists a directed path in G from s to v. Suppose that a DFS is run on G, starting from s. Then, true or false:

### CS 220: Discrete Structures and their Applications. graphs zybooks chapter 10

CS 220: Discrete Structures and their Applications graphs zybooks chapter 10 directed graphs A collection of vertices and directed edges What can this represent? undirected graphs A collection of vertices

### Computer Science & Engineering 423/823 Design and Analysis of Algorithms

Computer Science & Engineering 423/823 Design and Analysis of Algorithms Lecture 04 Elementary Graph Algorithms (Chapter 22) Stephen Scott (Adapted from Vinodchandran N. Variyam) sscott@cse.unl.edu Introduction

### Week 5. 1 Analysing BFS. 2 Depth-first search. 3 Analysing DFS. 4 Dags and topological sorting. 5 Detecting cycles. CS 270 Algorithms.

1 2 Week 5 3 4 5 General remarks We finish, by analysing it. Then we consider the second main graph- algorithm, depth-first (). And we consider one application of, of graphs. Reading from CLRS for week

### CS 341: Algorithms. Douglas R. Stinson. David R. Cheriton School of Computer Science University of Waterloo. February 26, 2019

CS 341: Algorithms Douglas R. Stinson David R. Cheriton School of Computer Science University of Waterloo February 26, 2019 D.R. Stinson (SCS) CS 341 February 26, 2019 1 / 296 1 Course Information 2 Introduction

### CS2 Algorithms and Data Structures Note 10. Depth-First Search and Topological Sorting

CS2 Algorithms and Data Structures Note 10 Depth-First Search and Topological Sorting In this lecture, we will analyse the running time of DFS and discuss a few applications. 10.1 A recursive implementation

### Topics. Trees Vojislav Kecman. Which graphs are trees? Terminology. Terminology Trees as Models Some Tree Theorems Applications of Trees CMSC 302

Topics VCU, Department of Computer Science CMSC 302 Trees Vojislav Kecman Terminology Trees as Models Some Tree Theorems Applications of Trees Binary Search Tree Decision Tree Tree Traversal Spanning Trees

### Data Structures and Algorithms Key to Homework Assignment 8

Data Structures and Algorithms Key to Homework Assignment 8. Apply the strong components algorithm to the digraph that has the following adjacency matrix: 0 4 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

### Part VI Graph algorithms. Chapter 22 Elementary Graph Algorithms Chapter 23 Minimum Spanning Trees Chapter 24 Single-source Shortest Paths

Part VI Graph algorithms Chapter 22 Elementary Graph Algorithms Chapter 23 Minimum Spanning Trees Chapter 24 Single-source Shortest Paths 1 Chapter 22 Elementary Graph Algorithms Representations of graphs

### Unweighted Graphs & Algorithms

Unweighted Graphs & Algorithms Zachary Friggstad Programming Club Meeting References Chapter 4: Graph (Section 4.2) Chapter 22: Elementary Graph Algorithms Graphs Features: vertices/nodes/dots and edges/links/lines

### CS/COE 1501 cs.pitt.edu/~bill/1501/ Graphs

CS/COE 1501 cs.pitt.edu/~bill/1501/ Graphs 5 3 2 4 1 0 2 Graphs A graph G = (V, E) Where V is a set of vertices E is a set of edges connecting vertex pairs Example: V = {0, 1, 2, 3, 4, 5} E = {(0, 1),

### Undirected Graphs. V = { 1, 2, 3, 4, 5, 6, 7, 8 } E = { 1-2, 1-3, 2-3, 2-4, 2-5, 3-5, 3-7, 3-8, 4-5, 5-6 } n = 8 m = 11

Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. V = {

### Basic Graph Algorithms

Basic Graph Algorithms 1 Representations of Graphs There are two standard ways to represent a graph G(V, E) where V is the set of vertices and E is the set of edges. adjacency list representation adjacency

### Design and Analysis of Algorithms

Design and Analysis of Algorithms CSE 5311 Lecture 18 Graph Algorithm Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 Graphs Graph G = (V,

### - Logic and Algorithms - Graph Algorithms

Fundamentals of Computer Sience and Digital Communications - Logic and Algorithms - Graph Algorithms Johan Larsson Marco Loh 22..24 Overview What is a Graph? Representations of Graphs Breadth-first Search

### Graph Algorithms. Definition

Graph Algorithms Many problems in CS can be modeled as graph problems. Algorithms for solving graph problems are fundamental to the field of algorithm design. Definition A graph G = (V, E) consists of

### BACKGROUND: A BRIEF INTRODUCTION TO GRAPH THEORY

BACKGROUND: A BRIEF INTRODUCTION TO GRAPH THEORY General definitions; Representations; Graph Traversals; Topological sort; Graphs definitions & representations Graph theory is a fundamental tool in sparse

### UNIT III TREES. A tree is a non-linear data structure that is used to represents hierarchical relationships between individual data items.

UNIT III TREES A tree is a non-linear data structure that is used to represents hierarchical relationships between individual data items. Tree: A tree is a finite set of one or more nodes such that, there

### Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 7 Greedy Graph Algorithms Topological sort Shortest paths Adam Smith The (Algorithm) Design Process 1. Work out the answer for some examples. Look for a general principle

### COT 6405 Introduction to Theory of Algorithms

COT 6405 Introduction to Theory of Algorithms Topic 14. Graph Algorithms 11/7/2016 1 Elementary Graph Algorithms How to represent a graph? Adjacency lists Adjacency matrix How to search a graph? Breadth-first

### ( ) ( ) C. " 1 n. ( ) \$ f n. ( ) B. " log( n! ) ( ) and that you already know ( ) ( ) " % g( n) ( ) " #&

CSE 0 Name Test Summer 008 Last 4 Digits of Mav ID # Multiple Choice. Write your answer to the LEFT of each problem. points each. The time for the following code is in which set? for (i=0; i

### Section Summary. Introduction to Trees Rooted Trees Trees as Models Properties of Trees

Chapter 11 Copyright McGraw-Hill Education. All rights reserved. No reproduction or distribution without the prior written consent of McGraw-Hill Education. Chapter Summary Introduction to Trees Applications

### Undirected Graphs. DSA - lecture 6 - T.U.Cluj-Napoca - M. Joldos 1

Undirected Graphs Terminology. Free Trees. Representations. Minimum Spanning Trees (algorithms: Prim, Kruskal). Graph Traversals (dfs, bfs). Articulation points & Biconnected Components. Graph Matching

### Algorithms and Theory of Computation. Lecture 3: Graph Algorithms

Algorithms and Theory of Computation Lecture 3: Graph Algorithms Xiaohui Bei MAS 714 August 20, 2018 Nanyang Technological University MAS 714 August 20, 2018 1 / 18 Connectivity In a undirected graph G

### Konigsberg Bridge Problem

Graphs Konigsberg Bridge Problem c C d g A Kneiphof e D a B b f c A C d e g D a b f B Euler s Graph Degree of a vertex: the number of edges incident to it Euler showed that there is a walk starting at

### Computer Science 385 Analysis of Algorithms Siena College Spring Topic Notes: Introduction and Overview

Computer Science 385 Analysis of Algorithms Siena College Spring 2011 Topic Notes: Introduction and Overview Welcome to Analysis of Algorithms! What is an Algorithm? A possible definition: a step-by-step

### Lecture 9 Graph Traversal

Lecture 9 Graph Traversal Euiseong Seo (euiseong@skku.edu) SWE00: Principles in Programming Spring 0 Euiseong Seo (euiseong@skku.edu) Need for Graphs One of unifying themes of computer science Closely

### Depth-First Search Depth-first search (DFS) is another way to traverse the graph.

Depth-First Search Depth-first search (DFS) is another way to traverse the graph. Motivating example: In a video game, you are searching for a path from a point in a maze to the exit. The maze can be modeled

### Trees and Graphs Shabsi Walfish NYU - Fundamental Algorithms Summer 2006

Trees and Graphs Basic Definitions Tree: Any connected, acyclic graph G = (V,E) E = V -1 n-ary Tree: Tree s/t all vertices of degree n+1 A root has degree n Binary Search Tree: A binary tree such that