Analysis of Algorithms, I

Advertisement


Advertisement
Similar documents
V. Adamchik 1. Graph Theory. Victor Adamchik. Fall of 2005

Discrete Mathematics & Mathematical Reasoning Chapter 10: Graphs

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge,

2.3 Scheduling jobs on identical parallel machines

Midterm Practice Problems

6.852: Distributed Algorithms Fall, Class 2

IE 680 Special Topics in Production Systems: Networks, Routing and Logistics*

12 Abstract Data Types

Social Media Mining. Graph Essentials

CS2 Algorithms and Data Structures Note 11. Breadth-First Search and Shortest Paths

Approximation Algorithms

SHARP BOUNDS FOR THE SUM OF THE SQUARES OF THE DEGREES OF A GRAPH

A Sublinear Bipartiteness Tester for Bounded Degree Graphs

CSC2420 Fall 2012: Algorithm Design, Analysis and Theory

The Goldberg Rao Algorithm for the Maximum Flow Problem

136 CHAPTER 4. INDUCTION, GRAPHS AND TREES

Max Flow, Min Cut, and Matchings (Solution)

Network (Tree) Topology Inference Based on Prüfer Sequence

Outline. NP-completeness. When is a problem easy? When is a problem hard? Today. Euler Circuits

Lecture 7: NP-Complete Problems

Topology-based network security

Lecture 15 An Arithmetic Circuit Lowerbound and Flows in Graphs

Zachary Monaco Georgia College Olympic Coloring: Go For The Gold

A Turán Type Problem Concerning the Powers of the Degrees of a Graph

Euler Paths and Euler Circuits

Class One: Degree Sequences

Handout #Ch7 San Skulrattanakulchai Gustavus Adolphus College Dec 6, Chapter 7: Digraphs

Partitioning edge-coloured complete graphs into monochromatic cycles and paths

A binary heap is a complete binary tree, where each node has a higher priority than its children. This is called heap-order property

Finding and counting given length cycles

Cycles in a Graph Whose Lengths Differ by One or Two

Distributed Computing over Communication Networks: Maximal Independent Set

Distance Degree Sequences for Network Analysis

8.1 Min Degree Spanning Tree

SPANNING CACTI FOR STRUCTURALLY CONTROLLABLE NETWORKS NGO THI TU ANH NATIONAL UNIVERSITY OF SINGAPORE

Data Structures in Java. Session 16 Instructor: Bert Huang

Divisor graphs have arbitrary order and size

Semi-Matchings for Bipartite Graphs and Load Balancing

Operations and Supply Chain Management Prof. G. Srinivasan Department of Management Studies Indian Institute of Technology, Madras

Graph Theory Problems and Solutions

Cost Model: Work, Span and Parallelism. 1 The RAM model for sequential computation:

Cpt S 223. School of EECS, WSU

10. Graph Matrices Incidence Matrix

GRAPH THEORY LECTURE 4: TREES

Home Page. Data Structures. Title Page. Page 1 of 24. Go Back. Full Screen. Close. Quit

(Refer Slide Time: 01.26)

Part 2: Community Detection

each college c i C has a capacity q i - the maximum number of students it will admit

Graphs without proper subgraphs of minimum degree 3 and short cycles

Labeling outerplanar graphs with maximum degree three

Answer: (a) Since we cannot repeat men on the committee, and the order we select them in does not matter, ( )

CSE 326, Data Structures. Sample Final Exam. Problem Max Points Score 1 14 (2x7) 2 18 (3x6) Total 92.

Course on Social Network Analysis Graphs and Networks

Connectivity and cuts

Scheduling. Open shop, job shop, flow shop scheduling. Related problems. Open shop, job shop, flow shop scheduling

Binary Search Trees CMPSC 122

Sociology and CS. Small World. Sociology Problems. Degree of Separation. Milgram s Experiment. How close are people connected? (Problem Understanding)


Simple Graphs Degrees, Isomorphism, Paths

SEMITOTAL AND TOTAL BLOCK-CUTVERTEX GRAPH

The LCA Problem Revisited

Information Theory and Coding Prof. S. N. Merchant Department of Electrical Engineering Indian Institute of Technology, Bombay

Graph Algorithms. Ananth Grama, Anshul Gupta, George Karypis, and Vipin Kumar

On the independence number of graphs with maximum degree 3

Asking Hard Graph Questions. Paul Burkhardt. February 3, 2014

Persistent Data Structures

Static Load Balancing

CMPSCI611: Approximating MAX-CUT Lecture 20

CS 598CSC: Combinatorial Optimization Lecture date: 2/4/2010

Mining Social-Network Graphs

Lecture 1: Course overview, circuits, and formulas

Fairness in Routing and Load Balancing

Applied Algorithm Design Lecture 5

! Solve problem to optimality. ! Solve problem in poly-time. ! Solve arbitrary instances of the problem. #-approximation algorithm.

A New Approach to Dynamic All Pairs Shortest Paths

Week 5 Integral Polyhedra

Full and Complete Binary Trees

8.5 PETRI NETS. Figure A computer program. Figure 8.5.2

5.1 Bipartite Matching

Ph.D. Thesis. Judit Nagy-György. Supervisor: Péter Hajnal Associate Professor

Diversity Coloring for Distributed Data Storage in Networks 1

! Solve problem to optimality. ! Solve problem in poly-time. ! Solve arbitrary instances of the problem. !-approximation algorithm.

Graphical degree sequences and realizations

Lattice Point Geometry: Pick s Theorem and Minkowski s Theorem. Senior Exercise in Mathematics. Jennifer Garbett Kenyon College

Network File Storage with Graceful Performance Degradation

Exponential time algorithms for graph coloring

Scheduling Home Health Care with Separating Benders Cuts in Decision Diagrams

Mean Ramsey-Turán numbers

The Basics of Graphical Models

Large induced subgraphs with all degrees odd

Cpt S 223. School of EECS, WSU

Social Media Mining. Network Measures

Chapter Load Balancing. Approximation Algorithms. Load Balancing. Load Balancing on 2 Machines. Load Balancing: Greedy Scheduling

ON THE COMPLEXITY OF THE GAME OF SET.

Cycles and clique-minors in expanders

6.3 Conditional Probability and Independence

2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]

2.3 Convex Constrained Optimization Problems

Examination paper for MA0301 Elementær diskret matematikk

SHORT CYCLE COVERS OF GRAPHS WITH MINIMUM DEGREE THREE

Advertisement
Transcription:

Analysis of Algorithms, I CSOR W4231.002 Eleni Drinea Computer Science Department Columbia University Thursday, February 26, 2015

Outline 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications of BFS

Today 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications of BFS

Review of the last lecture Sequence alignment A mathematical formulation of the problem A DP solution Graphs Directed/undirected, weighted/unweighted Trees Bipartite graphs

Today 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications of BFS

Degree theorem Theorem 1. In any graph, the sum of the degrees of all vertices is equal to twice the number of the edges. Proof. Every edge is incident to two vertices, thus contributes twice to the total sum of the degrees. (Summing the degrees of all vertices simply counts all instances of some edge being incident to some vertex.)

Running time of graph algorithms Input: graph G = (V, E), V = n, E = m Linear graph algorithms run in O(n + m) time Lower bound on m (assume connected graphs)? Upper bound on m (assume simple graphs)? for connected simple graphs, O(n + m) = O(m). More general running times: the best performance is determined by the relationship between n and m For example, O(n 3 ) is better than O(m 2 ) if the graph is dense (that is, m = Ω(n 2 ) edges)

Representing graphs: adjacency matrix We want to represent a graph G = (V, E), V = n, E = m. Adjacency matrix for G: an n n matrix A such that { 1, if edge (i, j) E A[i, j] = 0, otherwise Space required for adjacency matrix A = Θ(n 2 ) Space requirements can be improved if the graph is undirected: A is symmetric only store its upper triangle unweighted: only need one bit per entry

Pros/cons of adjacency matrix represention Representing G = (V, E), V = n, E = m by its adjacency matrix has the following pros/cons. Advantages: 1. check whether edge e E in constant time 2. easy to adapt if the graph is weighted 3. suitable for dense graphs where m = Θ(n 2 ) Drawbacks: 1. requires Ω(n 2 ) space even if G is sparse (m = o(n 2 )). 2. does not allow for linear time algorithms for sparse graphs (at least when all matrix entries must be examined).

Representing graphs: adjacency list An alternative representation for graph G = (V, E), V = n, E = m is as follows. Adjacency list: recall that vertex j is adjacent to vertex i if (i, j) E; then the adjacency list for vertex i is simply the list of vertices adjacent to vertex i. The adjacency list representation of a graph consists of an array A with n entries such that A[i] points to the adjacency list of vertex i.

Space requirements for adjacency list Need an array of n pointers: O(n) space; plus the sum of the lengths of all adjacency lists: directed G: maintain the list of vertices with incoming edges from v and the list of vertices with outgoing edges to v. length of adjacency lists of v = outdeg(v) + indeg(v) length of all adjacency lists = outdeg(v) + indeg(v) = 2m v undirected G: maintain the list of vertices adjacent to v length of adjacency list of v = deg(v) length of all adjacency lists = deg(v) = 2m. v Total space: O(n + m)

Pros/cons of representing G by its adjacency list Representing G = (V, E), V = n, E = m using adjacency lists has the following pros/cons. Advantages: allocates no unnecessary space: O(n + m) space to represent a graph on n vertices and m edges suitable for linear or near-linear time algorithms Drawbacks: searching for an edge can take O(n) time

Adjacency list vs Adjacency matrix We prefer adjacency matrix when we need determine quickly whether an edge is in the graph the graph is dense the graph is small (it is a simpler representation). We use an adjacency list otherwise.

Today 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications of BFS

Searching a graph Given a transportation network and a city s, we want all cities reachable from s. This problem is known as s-t connectivity. Input: a graph G = (V, E), a vertex s V Output: all vertices t such that there is a path from s to t

An algorithm for s-t connectivity: breadth-first search Breadth-first search (BFS): explore G starting from s outward in all possible directions, adding reachable nodes one layer at a time. First add all nodes that are joined by an edge to s: these nodes are at distance 1 from s and form the first layer. Then add all nodes that are joined by an edge to a node in the first layer; these are the nodes at distance 2 from s and form the second layer. And so on and so forth.

Example graph G 1 3 8 2 6 7 4 5

The BFS layers for the example graph 1 1st layer 2 3 1 2 3 2nd layer 4 5 6 7 8 Solid edges appear in G and the layers constructed by BFS. Dotted edges only appear in the input graph G.

Properties of the layers in BFS Formally Layer L 0 contains s. Layer L 1 contains all nodes v such that (s, v) E. For i 1, layer L i contains all nodes that 1. have an edge from a node in layer L i 1 ; and 2. do not belong to a previous layer. Then L i is the set of nodes that are at distance i from s. Thus the length of the shortest s-v path for all v L i equals i. Why?

L i is the set of nodes at distance i from s Proof by induction. Basis: true for layer L 0. Hypothesis: suppose L i is the set of nodes at distance i from s, for some i 0. Step: The only vertices added to L i+1 are those that 1. have an edge from a node in L i ; and 2. do not have an edge from any node in any previous layer L k, for k < i. Then L i+1 contains the nodes that are at distance 1 + i from s.

Output of BFS When is a node v reachable from s added to the graph produced by BFS? Why would a node fail to appear in the BFS graph? What problems are answered by BFS? Why is the graph produced by BFS a tree? Consider an edge (u, v) E that is not a tree edge; u, v must appear at some layers of the BFS tree, say L i, L j respectively. How far apart can these layers be?

Output of BFS When is a node v reachable from s added to the BFS graph? When a node u is explored such that for the first time there is an edge (u, v) in the graph. Then u becomes the parent of v since u is responsible for discovering v. Why would a node fail to appear in the BFS graph? Because there is no path from s to that node. Hence BFS 1. answers s-t connectivity; 2. computes shortest s-v paths for every node v reachable from s in unweighted graphs.

Properties of the BFS tree (cont d) Why is the graph produced by BFS a tree? Because it is connected and acyclic. Hence BFS produces a rooted tree on the set of nodes reachable from s. the order in which the vertices are visited matters for the final tree but not for the distances computed. What are graph edges that do not appear in the BFS tree? They are either edges between nodes in the same layer; or edges between nodes in adjacent layers This is a property of all BFS trees.

Non-tree edges in BFS trees Claim 1. Let T be a BFS tree, let x and y be nodes in T belonging to layers L i and L j respectively, and let (x, y) be an edge in G. Then i and j differ by at most 1.

Proof of Claim 1 Proof. Without loss of generality, assume that j i. When layer L i is examined and x is explored, either y is discovered then, hence y is added at layer L i+1 as a child of x; or y was discovered before x is explored at layer L i, thus y appears in the tree at some layer L k with k i. Since j i, y must appear at layer L i.

Implementing BFS We need to store the nodes discovered at layer L i in order to explore them later (once we have finished exploring layer L i ). To this end we use a queue. FIFO data structure: add to the end of the queue, extract from the head of the queue. Implemented as a double-linked list: maintain explicit pointers to the head and tail elements. Then enqueue and dequeue operations take constant time.

Pseudocode for BFS running time? BFS(G(V, E), s V ) array distance[v ] initialized to array discovered[v ] initialized to 0 queue q discovered(s) = 1 distance(s) = 0 parent(s) = NIL enqueue(q, s) while size(q) > 0 do u =dequeue(q) for (u, v) E do if discovered(v) == 0 then discovered(v) = 1 distance(v) = distance(u) + 1 parent(v) = u enqueue(q, v) end if end for end while

Today 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications of BFS

Connected components in undirected graphs BFS(s) naturally produces the connected component R(s) of vertex s, that is, the set of nodes reachable from s. exploring the vertices in a different order can yield different algorithms for finding connected components How can we produce all the connected components of G? Consider two distinct vertices s and t in G: how do their connected components compare?

Connected components of different vertices Fact 2. For any two vertices u and v their connected components are either the same or disjoint. Proof. Consider any two nodes s, t such that there is a path between them: their connected components are the same (why?). Now consider any two nodes s, t such that there is no path between them: their connected components are disjoint. If not, there is a node v that belongs to both components, hence a path between s and v and a path between t and v. Then there is a path between s and t, contradiction.

Finding all the connected components in a graph AllConnectedComponents(G = (V, E)) 1. Start with an arbitrary node s; run BFS(G, s) and output the resulting BFS tree as one connected component. 2. Continue with any node u that has not been visited by BFS(G, s); run BFS from u and output the resulting BFS tree as one connected component. 3. Repeat until all nodes in V have been visited.

Testing bipartiteness & graph 2-colorability Testing bipartiteness Input: a graph G = (V, E) Output: yes if G is bipartite, no otherwise Equivalent problem (why?) Input: a graph G = (V, E) Output: yes if and only if we can color all the vertices in G using at most 2 colors say red and white so that no edge has two endpoints with the same color

Why wouldn t we be able to 2-color a graph? Fact: If a graph contains an odd-length cycle, then it is not 2-colorable. Is this condition also sufficient? In other words, are odd cycles the only obstacle to bipartiteness?

Algorithm for 2-colorability BFS provides a natural way to 2-color a graph: 1. Start BFS from any vertex; color it red. Color white all nodes in the first layer L1 of the BFS tree. If there is an edge between two nodes in L 1, output no and stop. Otherwise, continue from layer L 1, coloring red the vertices in even layers and white in odd layers. 2. If all nodes are explored (hence 2-colored), output yes.

Analyzing the algorithm Upon termination of the algorithm either we successfully 2-colored all vertices and declared the graph bipartite; or we stopped at some level because there was an edge between two vertices of that level; in this case, we declared the graph non-bipartite. This algorithm is efficient. Is it correct?

Showing correctness We must show that if our algorithm outputs 1. yes, then the 2-coloring it provides is a valid 2-coloring for G; and 2. no, G is indeed not 2-colorable by any algorithm (e.g., because it contains an odd-length cycle). This can be formalized in the next claim which examines when the algorithm succeeds to 2-color G; this is determined by the existence of an edge between two nodes in the same layer.

Correctness of algorithm for 2-colorability Claim 2. Let G be a connected graph, and let L 1, L 2,... be the layers produced by BFS starting at node s. Then exactly one of the following two is true. 1. There is no edge of G joining two nodes in the same layer. Then G is bipartite and has no odd length cycles. 2. There is an edge of G joining two nodes of the same layer. Then G contains an odd length cycle, hence is not bipartite. Corollary 3. A graph is bipartite if and only if it contains no odd length cycle.

Proof of correctness, part 1: no edge between nodes in the same layer 1. Assume that no edge of G joins two nodes in the same layer of the BFS tree. By Claim 1, all edges in G not belonging to the BFS tree are either edges between nodes in the same layer; or edges between nodes in adjacent layers. Our assumption implies that all edges of G not appearing in the BFS tree are between nodes in adjacent layers. Since our coloring procedure gives such nodes different colors, the whole graph can be 2-colored, hence it is bipartite.

Proof of correctness, part 2: exists edge between nodes in the same layer 2. Assume that there is an edge (u, v) E between two nodes u and v in the same layer. Obviously G is not 2-colorable by our algorithm: both endpoints of edge (u, v) are assigned the same color. Our algorithm returns no, hence declares G non-bipartite. Can we show existence of an odd cycle and prove that G indeed is not 2-colorable by any algorithm?

Proof of correctness, part 2 Let u, v appear at layer L j and edge (u, v) E. Let z be the lowest common ancestor of u and v in the BFS tree (z might be s). Suppose z is at layer L i with i < j. Consider the following path in G: from z to u follow edges of the BFS tree, then edge (u, v) and back to z following edges of the BFS tree. This is a cycle starting and ending at z, consisting of (j i) + 1 + (j i) = 2(j i) + 1 edges, hence of odd length. s z u v