Dynamic Programming. Data Structures and Algorithms Andrei Bulatov

Size: px
Start display at page:

Transcription

1 Dynamic Programming Data Structures and Algorithms Andrei Bulatov

2 Algorithms Dynamic Programming 18-2 Weighted Interval Scheduling Weighted interval scheduling problem. Instance A set of n jobs. Job j starts at s j, finishes at f j, and has weight or value v j. Two jobs compatible if they don't overlap. Objective Find maximum weight subset of mutually compatible jobs.

3 Algorithms Dynamic Programming 18-3 Unweighted Interval Scheduling: Review Recall: Greedy algorithm works if all weights are 1. Consider jobs in ascending order of finish time. Add job to subset if it is compatible with previously chosen jobs. Observation. Greedy algorithm can fail spectacularly if arbitrary weights are allowed. weight = 999 weight = 1 a b Time

4 Algorithms Dynamic Programming 18-4 Weighted Interval Scheduling Notation: Label jobs by finishing time: f 1 f 2... f n. Let p(j) be the largest index i < j such that job i is compatible with j. Example. p(8) = 5, p(7) = 3, p(2) = Time

5 Algorithms Dynamic Programming 18-5 Dynamic Programming: Binary Choice Let OPT(j) denote the value of an optimal solution to the problem consisting of job requests 1, 2,..., j. Case 1: OPT selects job j. cannot use incompatible jobs { p(j) + 1, p(j) + 2,..., j - 1 } must include optimal solution to problem consisting of remaining compatible jobs 1, 2,..., p(j) Case 2: OPT does not select job j. optimal substructure must include optimal solution to problem consisting of remaining compatible jobs 1, 2,..., j-1 OPT ( j) = 0 max { v + OPT ( p( j)), OPT ( j 1) } j if j = 0 otherwise

6 Algorithms Dynamic Programming 18-6 Weighted Interval Scheduling: Brute Force Input: n, s 1,,s n, f 1,,f n, v 1,,v n sort jobs by finish times so that f 1 f 2 f n compute p(1), p(2),, p(n) return Compute-Opt(n) Compute-Opt(j) if (j = 0) return 0 else return max(v j +Compute-Opt(p(j)),Compute-Opt(j-1))

7 Algorithms Dynamic Programming 18-7 Weighted Interval Scheduling: Brute Force Observation. Recursive algorithm fails spectacularly because of redundant sub-problems exponential algorithms. Example Number of recursive calls for family of "layered" instances grows like Fibonacci sequence p(1) = 0, p(j) = j

8 Algorithms Dynamic Programming 18-8 Weighted Interval Scheduling: Memoization Memoization: Store results of each sub-problem in a cache; lookup as needed. Input: n, s 1,,s n, f 1,,f n, v 1,,v n sort jobs by finish times so that f 1 f 2 f n compute p(1), p(2),, p(n) set OPT[0]:=0 for j=1 to n do set OPT[j]:=max(v j +OPT[p(j)],OPT[j-1]) endfor return OPT[n]

9 Algorithms Dynamic Programming 18-9 Weighted Interval Scheduling: Running Time Theorem Memoized version of algorithm takes O(n log n) time. Proof Sort by finish time: O(n log n). Computing p( ) : O(n) after sorting by finish time Each iteration of the for loop: O(1) Overall time is O(n log n) Remark. O(n) if jobs are pre-sorted by finish times QED

10 Algorithms Dynamic Programming Automated Memoization Automated memoization. Many functional programming languages (e.g., Lisp) have built-in support for memoization. Q. Why not in imperative languages (e.g., Java)? (defun F (n) (if (<= n 1) n (+ (F (- n 1)) (F (- n 2))))) Lisp (efficient) static int F(int n) { if (n <= 1) return n; else return F(n-1) + F(n-2); } Java (exponential) F(40) F(39) F(38) F(38) F(37) F(37) F(36) F(37) F(36) F(36) F(35) F(36) F(35) F(35) F(34)

11 Algorithms Dynamic Programming Finding a Solution Dynamic programming algorithm computes optimal value. What if we want the solution itself? Do some post-processing Find-Solution(j) if j = 0 then output nothing else if v j +M[p(j)]>M[j-1] then do print j Find-Solution(p(j)) endif else Find-Solution(j-1) endif

12 Algorithms Dynamic Programming Knapsack The Knapsack Problem Instance: A set of n objects, each of which has a positive integer value and a positive integer weight. A weight limit W. Objective: w i Select objects so that their total weight does not exceed W, and they have maximal total value v i

13 Algorithms Dynamic Programming Idea A simple question: Should we include the last object into selection? Let OPT(n,W) denote the maximal value of a selection of objects out of {1,, n} such that the total weight of the selection doesn t exceed W More general, OPT(i,U) denote the maximal value of a selection of objects out of {1,, i} such that the total weight of the selection doesn t exceed U Then OPT(n,W) = max{ OPT(n 1, W), OPT(n 1, W w ) + v } i i

14 Algorithms Dynamic Programming Algorithm (First Try) Knapsack(n,W) set V1:=Knapsack(n-1,W) set V2:=Knapsack(n-1,W- ) v i output max(v1,v2+ ) w i Is it good enough? Example Let the values be 1,3,4,2, the weights 1,1,3,2, and W = 5 Recursion tree

15 Algorithms Dynamic Programming Another Idea: Memoization Let us store values OPT(i,U) as we find them We need to store (and compute) at most n W numbers We ll do it in a regular way: Instead of recursion, we will compute those values starting from smaller ones, and fill up a table

16 Algorithms Dynamic Programming Algorithm (Second Try) Knapsack(n,W) array M[0..n,0..W] set M[0,w]:=0 for each w=0,1,...,w for i=1 to n do for w=0 to W do set M[i,w]:= max{m[i 1,w],M[n-1,w ]+ } endfor endfor w i v i

17 Algorithms Dynamic Programming Example Example Let the values be 1,3,4,2, the weights 1,1,3,2, and W = 5 w 0 i w i M[i,w] = max{ M[ i 1, w], M[ n 1,w ] + } v i

18 Algorithms Dynamic Programming Shortest Path Suppose that every arc e of a digraph G has length (or cost, or weight, or ) len(e) But now we allow negative lengths (weights) Then we can naturally define the length of a directed path in G, and the distance between any two nodes The s-t-shortest Path Problem Instance: Digraph G with lengths of arcs, and nodes s,t Objective: Find a shortest path between s and t

19 Algorithms Dynamic Programming Shortest Path: Difficulties Negative Cycles. <0 s t Greediness fails t s 1 t t Adding constant weight to all arcs fails

20 Algorithms Dynamic Programming Shortest Path: Observations Assumption There are no negative cycles Lemma If graph G has no negative cycles, then there is a shortest path from s to t that is simple (i.e. does not repeat nodes), and hence has at most n 1 arcs Proof If a shortest path P from s to t repeat a node v, then it also include a cycle C starting and ending at v. The weight of the cycle is non-negative, therefore removing the cycle makes the path shorter (no longer). QED

21 Algorithms Dynamic Programming Shortest Path: Dynamic Programming We will be looking for a shortest path with increasing number of arcs Let OPT(i,v) denote the minimum weight of a path from v to t using at most i arcs v w t Shortest v t path can use i 1 arcs. Then OPT(i,v) = OPT(i 1,v) Or it can use i arcs and the first arc is vw. Then OPT(i,v) = len(vw) + OPT(i 1,w) OPT ( i, v) = min{ OPT ( i 1, v),min{ OPT ( i 1, w) + len( vw)}} w V

22 Algorithms Dynamic Programming Shortest Path: Bellman-Ford Algorithm Shortest-Path(G,s,t) set n:= V /*number of nodes in G array M[0..n-1,V] set M[0,t]:=0 and M[0,v]:= for each v V-{t} for i=1 to n-1 do for v V do set M[i,w]:=min{M[i-1,v],min {M[i-1,w]+len(vw)}} endfor endfor return m[n-1,s] w V

23 Algorithms Dynamic Programming Example -4 8 v v v v v v -3 t a b c d e M[i,w] = min{ M[i 1, v], min { M[ i 1, w] + len(vw) }} w V

24 Algorithms Dynamic Programming Shortest Path: Soundness and Running Time Theorem The ShortestPath algorithm correctly computes the minimum cost of an s-t path in any graph that has no negative cycles, and runs in 3 O( n ) time Proof. Soundness follows by induction from the recurrent relation for the optimal value. DIY. Running time: 2 We fill up a table with n entries. Each of them requires O(n) time

25 Algorithms Dynamic Programming Shortest Path: Soundness and Running Time Theorem The ShortestPath algorithm can be implemented in O(mn) time A big improvement for sparse graphs Proof. Consider the computation of the array entry M[i,v]: M[i,v] = min{ M[i 1, v], min { M[ i 1, w] + len(vw) }} We need only compute the minimum over all nodes w for which v has an edge to w n v w V Let denote the number of such edges

26 Algorithms Dynamic Programming Shortest Path: Running Time Improvements It takes O( ) to compute the array entry M[i,v]. n v It needs to be computed for every node v and for each i, 1 i n. Thus the bound for running time is O n n = O(nm) v v V n v Indeed, is the outdegree of v, and we have the result by the Handshaking Lemma. QED

27 Algorithms Dynamic Programming Shortest Path: Space Improvements The straightforward implementation requires storing a table with entries It can be reduced to O(n) Instead of recording M[i,v] for each i, we use and update a single value M[v] for each node v, the length of the shortest path from v to t found so far Thus we use the following recurrent relation: M[v] = min{ M[v], min { M[ w] + len(vw) }} w V

28 Algorithms Dynamic Programming Shortest Path: Space Improvements (cntd) Lemma Throughout the algorithm M[v] is the length of some path from v to t, and after i rounds of updates the value M[v] is no larger than the length of the shortest from v to t using at most i edges

29 Algorithms Dynamic Programming Shortest Path: Finding Shortest Path In the standard version we only need to keep record on how the optimum is achieved Consider the space saving version. For each node v store the first node on its path to the destination t Denote it by first(v) Update it every time M[v] is updated Let P be the pointer graph P = (V, {(v, first(v)): v V})

30 Algorithms Dynamic Programming Shortest Path: Finding Shortest Path Lemma If the pointer graph P contains a cycle C, then this cycle must have negative cost. Proof If w = first(v) at any time, then M[v] M[w] + len(vw) Let v 1, v2, K, v k be the nodes along the cycle C, and ( v k, v 1) the last arc to be added Consider the values right before this arc is added We have M v ] M[ v ] len( v v ) for i = 1,, k 1 and M [ i i+ 1 + i i+ 1 [ vk ] > M[ v1 ] + len( vkv1 ) k 1 0 > i= 1 Adding up all the inequalities we get len( v v i i+ 1 ) + len( vkv1 )

31 Algorithms Dynamic Programming Shortest Path: Finding Shortest Path (cntd) Lemma Suppose G has no negative cycles, and let P be the pointer graph after termination of the algorithm. For each node v, the path in P from v to t is a shortest v-t path in G. Proof Observe that P is a tree. Since the algorithm terminates we have M[v] = M[w] + len(vw), where w = first(v). As M[t] = 0, the length of the path traced out by the pointer graph is exactly M[v], which is the shortest path distance. QED

32 Algorithms Dynamic Programming Shortest Path: Finding Negative Cycles Two questions: - how to decide if there is a negative cycle? - how to find one? Lemma It suffices to find negative cycles C such that t can be reached from C <0 <0 t

33 Algorithms Dynamic Programming Shortest Path: Finding Negative Cycles Proof Let G be a graph The augmented graph, A(G), is obtained by adding a new node and connecting every node in G with the new node t As is easily seen, G contains a negative cycle if and only if A(G) contains a negative cycle C such that t is reachable from C QED

34 Algorithms Dynamic Programming Shortest Path: Finding Negative Cycles (cntd) Extend OPT(i,v) to i n If the graph G does not contain negative cycles then OPT(i,v) = OPT(n 1,v) for all nodes v and all i n Indeed, it follows from the observation that every shortest path contains at most n 1 arcs. Lemma There is no negative cycle with a path to t if and only if OPT(n,v) = OPT(n 1,v) Proof If there is no negative cycle, then OPT(n,v) = OPT(n 1,v) for all nodes v by the observation above

35 Algorithms Dynamic Programming Shortest Path: Finding Negative Cycles (cntd) Proof (cntd) Suppose OPT(n,v) = OPT(n 1,v) for all nodes v. Therefore OPT(n,v) = min{ OPT(n 1,v), min { OPT(n 1,w) + len(vw) }} w V = min{ OPT(n,v), min { OPT(n,w) + len(vw) }} = OPT(n + 1,v) =. w V However, if a negative cycle from which t is reachable exists, then lim OPT ( i, v) = i

36 Algorithms Dynamic Programming Shortest Path: Finding Negative Cycles (cntd) Let v be a node such that OPT(n,v) OPT(n 1,v). A path P from v to t of weight OPT(n,v) must use exactly n arcs Any simple path can have at most n 1 arcs, therefore P contains a cycle C Lemma If G has n nodes and OPT(n,v) OPT(n 1,v), then a path P of weight OPT(n,v) contains a cycle C, and C is negative. Proof Every path from v to t using less than n arcs has greater weight. Let w be a node that occurs in P more than once. Let C be the cycle between the two occurrences of w Deleting C we get a shorter path of greater weight, thus C is negative

Dynamic Programming: Interval Scheduling and Knapsack

Dynamic Programming: Interval Scheduling and Knapsack . Weighted Interval Scheduling Weighted Interval Scheduling Weighted interval scheduling problem. Job j starts at s j, finishes at f j, and has weight

Dynamic Programming. Cormen et. al. IV 15

Dynamic Programming Cormen et. al. IV 5 Dynamic Programming Applications Areas. Bioinformatics. Control theory. Operations research. Some famous dynamic programming algorithms. Unix diff for comparing

CSE 421 Dynamic Programming

CSE Dynamic Programming Yin Tat Lee Weighted Interval Scheduling Interval Scheduling Job j starts at s(j) and finishes at f j and has weight w j Two jobs compatible if they don t overlap. Goal: find maximum

Dynamic Programming 1

Dynamic Programming 1 lgorithmic Paradigms Divide-and-conquer. Break up a problem into two sub-problems, solve each sub-problem independently, and combine solution to sub-problems to form solution to original

6. DYNAMIC PROGRAMMING I

6. DYNAMIC PROGRAMMING I weighted interval scheduling segmented least squares knapsack problem RNA secondary structure Lecture slides by Kevin Wayne Copyright 2005 Pearson-Addison Wesley Copyright 2013

Dynamic Programming. Weighted Interval Scheduling. Algorithmic Paradigms. Dynamic Programming

lgorithmic Paradigms Dynamic Programming reed Build up a solution incrementally, myopically optimizing some local criterion Divide-and-conquer Break up a problem into two sub-problems, solve each sub-problem

Lecture 2: Divide and conquer and Dynamic programming

Chapter 2 Lecture 2: Divide and conquer and Dynamic programming 2.1 Divide and Conquer Idea: - divide the problem into subproblems in linear time - solve subproblems recursively - combine the results in

//8 Fast Integer Division Too (!) Schönhage Strassen algorithm CS 8: Algorithm Design and Analysis Integer division. Given two n-bit (or less) integers s and t, compute quotient q = s / t and remainder

CS 580: Algorithm Design and Analysis

CS 580: Algorithm Design and Analysis Jeremiah Blocki Purdue University Spring 208 Announcement: Homework 3 due February 5 th at :59PM Final Exam (Tentative): Thursday, May 3 @ 8AM (PHYS 203) Recap: Divide

Dynamic Programming( Weighted Interval Scheduling)

Dynamic Programming( Weighted Interval Scheduling) 17 November, 2016 Dynamic Programming 1 Dynamic programming algorithms are used for optimization (for example, finding the shortest path between two points,

/9/ lgorithmic Paradigms hapter Dynamic Programming reed. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer. Break up a problem into two sub-problems, solve

CSE 421 Weighted Interval Scheduling, Knapsack, RNA Secondary Structure

CSE Weighted Interval Scheduling, Knapsack, RNA Secondary Structure Shayan Oveis haran Weighted Interval Scheduling Interval Scheduling Job j starts at s(j) and finishes at f j and has weight w j Two jobs

Areas. ! Bioinformatics. ! Control theory. ! Information theory. ! Operations research. ! Computer science: theory, graphics, AI, systems,.

lgorithmic Paradigms hapter Dynamic Programming reed Build up a solution incrementally, myopically optimizing some local criterion Divide-and-conquer Break up a problem into two sub-problems, solve each

13 Dynamic Programming (3) Optimal Binary Search Trees Subset Sums & Knapsacks

13 Dynamic Programming (3) Optimal Binary Search Trees Subset Sums & Knapsacks Average-case analysis Average-case analysis of algorithms and data structures: Input is generated according to a known probability

Chapter 6. Dynamic Programming. CS 350: Winter 2018

Chapter 6 Dynamic Programming CS 350: Winter 2018 1 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer. Break up a problem into

Dynamic Programming 11/8/2009. Weighted Interval Scheduling. Weighted Interval Scheduling. Unweighted Interval Scheduling: Review

//9 Algorihms Dynamic Programming - Weighed Ineral Scheduling Dynamic Programming Weighed ineral scheduling problem. Insance A se of n jobs. Job j sars a s j, finishes a f j, and has weigh or alue j. Two

Chapter 6. Weighted Interval Scheduling. Dynamic Programming. Algorithmic Paradigms. Dynamic Programming Applications

lgorithmic Paradigms hapter Dynamic Programming reedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer. Break up a problem into sub-problems, solve each

Aside: Golden Ratio. Golden Ratio: A universal law. Golden ratio φ = lim n = 1+ b n = a n 1. a n+1 = a n + b n, a n+b n a n

Aside: Golden Ratio Golden Ratio: A universal law. Golden ratio φ = lim n a n+b n a n = 1+ 5 2 a n+1 = a n + b n, b n = a n 1 Ruta (UIUC) CS473 1 Spring 2018 1 / 41 CS 473: Algorithms, Spring 2018 Dynamic

6. DYNAMIC PROGRAMMING I

6. DYNAMIC PRORAMMIN I weighted interval scheduling segmented least squares knapsack problem RNA secondary structure Lecture slides by Kevin Wayne Copyright 2005 Pearson-Addison Wesley http://www.cs.princeton.edu/~wayne/kleinberg-tardos

Chapter 6 Dynamic Programming Slides by Kevin Wayne. Copyright 2005 Pearson-Addison Wesley. All rights reserved. 1 6.8 Shortest Paths Shortest Paths Shortest path problem. Given a directed graph G = (V,

6. DYNAMIC PROGRAMMING I

lgorithmic paradigms 6. DYNMI PRORMMIN I weighted interval scheduling segmented least squares knapsack problem RN secondary structure reedy. Build up a solution incrementally, myopically optimizing some

CSE 431/531: Analysis of Algorithms. Dynamic Programming. Lecturer: Shi Li. Department of Computer Science and Engineering University at Buffalo

CSE 431/531: Analysis of Algorithms Dynamic Programming Lecturer: Shi Li Department of Computer Science and Engineering University at Buffalo Paradigms for Designing Algorithms Greedy algorithm Make a

CS Lunch. Dynamic Programming Recipe. 2 Midterm 2! Slides17 - Segmented Least Squares.key - November 16, 2016

CS Lunch 1 Michelle Oraa Ali Tien Dao Vladislava Paskova Nan Zhuang Surabhi Sharma Wednesday, 12:15 PM Kendade 307 2 Midterm 2! Monday, November 21 In class Covers Greedy Algorithms Closed book Dynamic

Data Structures and Algorithms CMPSC 465

ata Structures and Algorithms MPS LTUR ellman-ford Shortest Paths Algorithm etecting Negative ost ycles Adam Smith // A. Smith; based on slides by K. Wayne,. Leiserson,. emaine L. Negative Weight dges

1.1 First Problem: Stable Matching. Six medical students and four hospitals. Student Preferences. s6 h3 h1 h4 h2. Stable Matching Problem

//0 hapter Introduction: Some Representative Problems Slides by Kevin ayne. opyright 00 Pearson-ddison esley. ll rights reserved.. First Problem: Stable Matching Six medical students and four hospitals

This means that we can assume each list ) is

This means that we can assume each list ) is of the form ),, ( )with < and Since the sizes of the items are integers, there are at most +1pairs in each list Furthermore, if we let = be the maximum possible

CMPS 6610 Fall 2018 Shortest Paths Carola Wenk

CMPS 6610 Fall 018 Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk Paths in graphs Consider a digraph G = (V, E) with an edge-weight function w

Matrix Multiplication. Data Structures and Algorithms Andrei Bulatov

Matrix Multiplicatio Data Structures ad Algorithms Adrei Bulatov Algorithms Matrix Multiplicatio 7- Matrix Multiplicatio Matrix multiplicatio. Give two -by- matrices A ad B, compute A B. k kj ik ij b a

Dynamic Programming: Shortest Paths and DFA to Reg Exps

CS 374: Algorithms & Models of Computation, Spring 207 Dynamic Programming: Shortest Paths and DFA to Reg Exps Lecture 8 March 28, 207 Chandra Chekuri (UIUC) CS374 Spring 207 / 56 Part I Shortest Paths

CS 561, Lecture: Greedy Algorithms. Jared Saia University of New Mexico

CS 561, Lecture: Greedy Algorithms Jared Saia University of New Mexico Outline Greedy Algorithm Intro Activity Selection Knapsack 1 Greedy Algorithms Greed is Good - Michael Douglas in Wall Street A greedy

Today s Outline. CS 561, Lecture 15. Greedy Algorithms. Activity Selection. Greedy Algorithm Intro Activity Selection Knapsack

Today s Outline CS 561, Lecture 15 Jared Saia University of New Mexico Greedy Algorithm Intro Activity Selection Knapsack 1 Greedy Algorithms Activity Selection Greed is Good - Michael Douglas in Wall

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

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 = {, 2, 3,,,, 7, 8 } E

Dynamic Programming: Shortest Paths and DFA to Reg Exps

CS 374: Algorithms & Models of Computation, Fall 205 Dynamic Programming: Shortest Paths and DFA to Reg Exps Lecture 7 October 22, 205 Chandra & Manoj (UIUC) CS374 Fall 205 / 54 Part I Shortest Paths with

6. DYNAMIC PROGRAMMING II. sequence alignment Hirschberg's algorithm Bellman-Ford distance vector protocols negative cycles in a digraph

6. DYNAMIC PROGRAMMING II sequence alignment Hirschberg's algorithm Bellman-Ford distance vector protocols negative cycles in a digraph Shortest paths Shortest path problem. Given a digraph G = (V, E),

6. DYNAMIC PROGRAMMING II

6. DYNAMIC PROGRAMMING II sequence alignment Hirschberg's algorithm Bellman-Ford algorithm distance vector protocols negative cycles in a digraph Lecture slides by Kevin Wayne Copyright 2005 Pearson-Addison

CS60007 Algorithm Design and Analysis 2018 Assignment 1

CS60007 Algorithm Design and Analysis 2018 Assignment 1 Palash Dey and Swagato Sanyal Indian Institute of Technology, Kharagpur Please submit the solutions of the problems 6, 11, 12 and 13 (written in

Design and Analysis of Algorithms

CSE 0, Winter 08 Design and Analysis of Algorithms Lecture 8: Consolidation # (DP, Greed, NP-C, Flow) Class URL: http://vlsicad.ucsd.edu/courses/cse0-w8/ Followup on IGO, Annealing Iterative Global Optimization

Chapter 4 Greedy Algorithms Slides by Kevin Wayne. Copyright 2005 Pearson-Addison Wesley. All rights reserved. 1 4.1 Interval Scheduling Interval Scheduling Interval scheduling. Job j starts at s j and

Matching Residents to Hospitals

Midterm Review Matching Residents to Hospitals Goal. Given a set of preferences among hospitals and medical school students, design a self-reinforcing admissions process. Unstable pair: applicant x and

Greedy Algorithms My T. UF

Introduction to Algorithms Greedy Algorithms @ UF Overview A greedy algorithm always makes the choice that looks best at the moment Make a locally optimal choice in hope of getting a globally optimal solution

Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths

Matroids Shortest Paths Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths Marc Uetz University of Twente m.uetz@utwente.nl Lecture 2: sheet 1 / 25 Marc Uetz Discrete Optimization Matroids

Single Source Shortest Paths

CMPS 00 Fall 017 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk Paths in graphs Consider a digraph G = (V, E) with an edge-weight

Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 5 Greedy Algorithms Interval Scheduling Interval Partitioning Guest lecturer: Martin Furer Review In a DFS tree of an undirected graph, can there be an edge (u,v)

Chapter 4 Greedy Algorithms Slides by Kevin Wayne. Copyright Pearson-Addison Wesley. All rights reserved. 4 4.1 Interval Scheduling Interval Scheduling Interval scheduling. Job j starts at s j and finishes

/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Dynamic Programming II Date: 10/12/17

601.433/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Dynamic Programming II Date: 10/12/17 12.1 Introduction Today we re going to do a couple more examples of dynamic programming. While

FINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016)

FINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016) The final exam will be on Thursday, May 12, from 8:00 10:00 am, at our regular class location (CSI 2117). It will be closed-book and closed-notes, except

Partha Sarathi Mandal

MA 252: Data Structures and Algorithms Lecture 32 http://www.iitg.ernet.in/psm/indexing_ma252/y12/index.html Partha Sarathi Mandal Dept. of Mathematics, IIT Guwahati The All-Pairs Shortest Paths Problem

CSE 421 Introduction to Algorithms Final Exam Winter 2005

NAME: CSE 421 Introduction to Algorithms Final Exam Winter 2005 P. Beame 14 March 2005 DIRECTIONS: Answer the problems on the exam paper. Open book. Open notes. If you need extra space use the back of

University of Toronto Department of Electrical and Computer Engineering. Final Examination. ECE 345 Algorithms and Data Structures Fall 2016

University of Toronto Department of Electrical and Computer Engineering Final Examination ECE 345 Algorithms and Data Structures Fall 2016 Print your first name, last name, UTORid, and student number neatly

CS2223 Algorithms D Term 2009 Exam 3 Solutions

CS2223 Algorithms D Term 2009 Exam 3 Solutions May 4, 2009 By Prof. Carolina Ruiz Dept. of Computer Science WPI PROBLEM 1: Asymptoptic Growth Rates (10 points) Let A and B be two algorithms with runtimes

Discrete Wiskunde II. Lecture 5: Shortest Paths & Spanning Trees

, 2009 Lecture 5: Shortest Paths & Spanning Trees University of Twente m.uetz@utwente.nl wwwhome.math.utwente.nl/~uetzm/dw/ Shortest Path Problem "#\$%&'%()*%"()\$#+,&- Given directed "#\$%&'()*+,%+('-*.#/'01234564'.*,'7+"-%/8',&'5"4'84%#3

CS 580: Algorithm Design and Analysis

CS 58: Algorithm Design and Analysis Jeremiah Blocki Purdue University Spring 28 Announcement: Homework 3 due February 5 th at :59PM Midterm Exam: Wed, Feb 2 (8PM-PM) @ MTHW 2 Recap: Dynamic Programming

Algoritmiek, bijeenkomst 3

Algoritmiek, bijeenkomst 3 Mathijs de Weerdt Today Introduction Greedy Divide and Conquer (very briefly) Dynamic programming Slides with thanks to Kevin Wayne and Pearson Education (made available together

Knapsack and Scheduling Problems. The Greedy Method

The Greedy Method: Knapsack and Scheduling Problems The Greedy Method 1 Outline and Reading Task Scheduling Fractional Knapsack Problem The Greedy Method 2 Elements of Greedy Strategy An greedy algorithm

Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 6 Greedy Algorithms Interval Scheduling Interval Partitioning Scheduling to Minimize Lateness Sofya Raskhodnikova S. Raskhodnikova; based on slides by E. Demaine,

CS473 - Algorithms I

CS473 - Algorithms I Lecture 10 Dynamic Programming View in slide-show mode CS 473 Lecture 10 Cevdet Aykanat and Mustafa Ozdal, Bilkent University 1 Introduction An algorithm design paradigm like divide-and-conquer

Weighted Activity Selection

Weighted Activity Selection Problem This problem is a generalization of the activity selection problem that we solvd with a greedy algorithm. Given a set of activities A = {[l, r ], [l, r ],..., [l n,

Dynamic programming. Curs 2015

Dynamic programming. Curs 2015 Fibonacci Recurrence. n-th Fibonacci Term INPUT: n nat QUESTION: Compute F n = F n 1 + F n 2 Recursive Fibonacci (n) if n = 0 then return 0 else if n = 1 then return 1 else

Algorithms and Theory of Computation. Lecture 9: Dynamic Programming

Algorithms and Theory of Computation Lecture 9: Dynamic Programming Xiaohui Bei MAS 714 September 10, 2018 Nanyang Technological University MAS 714 September 10, 2018 1 / 21 Recursion in Algorithm Design

Announcements. CompSci 102 Discrete Math for Computer Science. Chap. 3.1 Algorithms. Specifying Algorithms

CompSci 102 Discrete Math for Computer Science Announcements Read for next time Chap. 3.1-3.3 Homework 3 due Tuesday We ll finish Chapter 2 first today February 7, 2012 Prof. Rodger Chap. 3.1 Algorithms

More Dynamic Programming

CS 374: Algorithms & Models of Computation, Spring 2017 More Dynamic Programming Lecture 14 March 9, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 42 What is the running time of the following? Consider

More Dynamic Programming

Algorithms & Models of Computation CS/ECE 374, Fall 2017 More Dynamic Programming Lecture 14 Tuesday, October 17, 2017 Sariel Har-Peled (UIUC) CS374 1 Fall 2017 1 / 48 What is the running time of the following?

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

Computer Science & Engineering 423/823 Design and Analysis of Algorithms Lecture 03 Dynamic Programming (Chapter 15) Stephen Scott and Vinodchandran N. Variyam sscott@cse.unl.edu 1/44 Introduction Dynamic

DAA Unit- II Greedy and Dynamic Programming. By Mrs. B.A. Khivsara Asst. Professor Department of Computer Engineering SNJB s KBJ COE, Chandwad

DAA Unit- II Greedy and Dynamic Programming By Mrs. B.A. Khivsara Asst. Professor Department of Computer Engineering SNJB s KBJ COE, Chandwad 1 Greedy Method 2 Greedy Method Greedy Principal: are typically

Single Source Shortest Paths

CMPS 00 Fall 015 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk 1 Paths in graphs Consider a digraph G = (V, E) with an edge-weight

Algorithms: Lecture 12. Chalmers University of Technology

Algorithms: Lecture 1 Chalmers University of Technology Today s Topics Shortest Paths Network Flow Algorithms Shortest Path in a Graph Shortest Path Problem Shortest path network. Directed graph G = (V,

Dynamic programming. Curs 2017

Dynamic programming. Curs 2017 Fibonacci Recurrence. n-th Fibonacci Term INPUT: n nat QUESTION: Compute F n = F n 1 + F n 2 Recursive Fibonacci (n) if n = 0 then return 0 else if n = 1 then return 1 else

CS 4407 Algorithms Lecture: Shortest Path Algorithms

CS 440 Algorithms Lecture: Shortest Path Algorithms Prof. Gregory Provan Department of Computer Science University College Cork 1 Outline Shortest Path Problem General Lemmas and Theorems. Algorithms Bellman-Ford

Advanced Analysis of Algorithms - Midterm (Solutions)

Advanced Analysis of Algorithms - Midterm (Solutions) K. Subramani LCSEE, West Virginia University, Morgantown, WV {ksmani@csee.wvu.edu} 1 Problems 1. Solve the following recurrence using substitution:

Recurrences COMP 215

Recurrences COMP 215 Analysis of Iterative Algorithms //return the location of the item matching x, or 0 if //no such item is found. index SequentialSearch(keytype[] S, in, keytype x) { index location

CSE 202 Homework 4 Matthias Springer, A

CSE 202 Homework 4 Matthias Springer, A99500782 1 Problem 2 Basic Idea PERFECT ASSEMBLY N P: a permutation P of s i S is a certificate that can be checked in polynomial time by ensuring that P = S, and

Greedy. Outline CS141. Stefano Lonardi, UCR 1. Activity selection Fractional knapsack Huffman encoding Later:

October 5, 017 Greedy Chapters 5 of Dasgupta et al. 1 Activity selection Fractional knapsack Huffman encoding Later: Outline Dijkstra (single source shortest path) Prim and Kruskal (minimum spanning tree)

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

Computer Science & Engineering 423/823 Design and Analysis of s Lecture 09 Dynamic Programming (Chapter 15) Stephen Scott (Adapted from Vinodchandran N. Variyam) 1 / 41 Spring 2010 Dynamic programming

CPSC 320 (Intermediate Algorithm Design and Analysis). Summer Instructor: Dr. Lior Malka Final Examination, July 24th, 2009

CPSC 320 (Intermediate Algorithm Design and Analysis). Summer 2009. Instructor: Dr. Lior Malka Final Examination, July 24th, 2009 Student ID: INSTRUCTIONS: There are 6 questions printed on pages 1 7. Exam

Topic 17. Analysis of Algorithms

Topic 17 Analysis of Algorithms Analysis of Algorithms- Review Efficiency of an algorithm can be measured in terms of : Time complexity: a measure of the amount of time required to execute an algorithm

Dynamic Programming. Credits: Many of these slides were originally authored by Jeff Edmonds, York University. Thanks Jeff!

Dynamic Programming Credits: Many of these slides were originally authored by Jeff Edmonds, York University. Thanks Jeff! Optimization Problems For most, the best known algorithm runs in exponential time.

CSE 421 Greedy Algorithms / Interval Scheduling

CSE 421 Greedy Algorithms / Interval Scheduling Yin Tat Lee 1 Interval Scheduling Job j starts at s(j) and finishes at f(j). Two jobs compatible if they don t overlap. Goal: find maximum subset of mutually

CMPS 2200 Fall Carola Wenk Slides courtesy of Charles Leiserson with small changes by Carola Wenk. 10/8/12 CMPS 2200 Intro.

CMPS 00 Fall 01 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with small changes by Carola Wenk 1 Paths in graphs Consider a digraph G = (V, E) with edge-weight function

Activity selection. Goal: Select the largest possible set of nonoverlapping (mutually compatible) activities.

Greedy Algorithm 1 Introduction Similar to dynamic programming. Used for optimization problems. Not always yield an optimal solution. Make choice for the one looks best right now. Make a locally optimal

Coin Changing: Give change using the least number of coins. Greedy Method (Chapter 10.1) Attempt to construct an optimal solution in stages.

IV-0 Definitions Optimization Problem: Given an Optimization Function and a set of constraints, find an optimal solution. Optimal Solution: A feasible solution for which the optimization function has the

Algorithm Design Strategies V

Algorithm Design Strategies V Joaquim Madeira Version 0.0 October 2016 U. Aveiro, October 2016 1 Overview The 0-1 Knapsack Problem Revisited The Fractional Knapsack Problem Greedy Algorithms Example Coin

Design and Analysis of Algorithms

Design and Analysis of Algorithms CSE 5311 Lecture 21 Single-Source Shortest Paths Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 Single-Source

Data Structures in Java

Data Structures in Java Lecture 21: Introduction to NP-Completeness 12/9/2015 Daniel Bauer Algorithms and Problem Solving Purpose of algorithms: find solutions to problems. Data Structures provide ways

Week 7 Solution. The two implementations are 1. Approach 1. int fib(int n) { if (n <= 1) return n; return fib(n 1) + fib(n 2); } 2.

Week 7 Solution 1.You are given two implementations for finding the nth Fibonacci number(f Fibonacci numbers are defined by F(n = F(n 1 + F(n 2 with F(0 = 0 and F(1 = 1 The two implementations are 1. Approach

Shortest paths with negative lengths

Chapter 8 Shortest paths with negative lengths In this chapter we give a linear-space, nearly linear-time algorithm that, given a directed planar graph G with real positive and negative lengths, but no

Discrete Optimization 2010 Lecture 3 Maximum Flows

Remainder: Shortest Paths Maximum Flows Discrete Optimization 2010 Lecture 3 Maximum Flows Marc Uetz University of Twente m.uetz@utwente.nl Lecture 3: sheet 1 / 29 Marc Uetz Discrete Optimization Outline

Greedy Algorithms. Kleinberg and Tardos, Chapter 4

Greedy Algorithms Kleinberg and Tardos, Chapter 4 1 Selecting breakpoints Road trip from Fort Collins to Durango on a given route. Fuel capacity = C. Goal: makes as few refueling stops as possible. Greedy

1 Basic Definitions. 2 Proof By Contradiction. 3 Exchange Argument

1 Basic Definitions A Problem is a relation from input to acceptable output. For example, INPUT: A list of integers x 1,..., x n OUTPUT: One of the three smallest numbers in the list An algorithm A solves

Question Paper Code :

www.vidyarthiplus.com Reg. No. : B.E./B.Tech. DEGREE EXAMINATION, NOVEMBER/DECEMBER 2011. Time : Three hours Fourth Semester Computer Science and Engineering CS 2251 DESIGN AND ANALYSIS OF ALGORITHMS (Regulation

CMSC 451: Lecture 7 Greedy Algorithms for Scheduling Tuesday, Sep 19, 2017

CMSC CMSC : Lecture Greedy Algorithms for Scheduling Tuesday, Sep 9, 0 Reading: Sects.. and. of KT. (Not covered in DPV.) Interval Scheduling: We continue our discussion of greedy algorithms with a number

CS Analysis of Recursive Algorithms and Brute Force

CS483-05 Analysis of Recursive Algorithms and Brute Force Instructor: Fei Li Room 443 ST II Office hours: Tue. & Thur. 4:30pm - 5:30pm or by appointments lifei@cs.gmu.edu with subject: CS483 http://www.cs.gmu.edu/

Analysis of Algorithms. Outline. Single Source Shortest Path. Andres Mendez-Vazquez. November 9, Notes. Notes

Analysis of Algorithms Single Source Shortest Path Andres Mendez-Vazquez November 9, 01 1 / 108 Outline 1 Introduction Introduction and Similar Problems General Results Optimal Substructure Properties