![DP solution –step 2
• A recursive solution
• Assume c[n+1,n+1] with c[i,j] is the number of activities in a
maximum-size subset of mutually compatible activities in Sij. So the
solution is c[0,n+1]=S0,n+1.
• C[i,j]= 0 if Sij=
max{c[i,k]+c[k,j]+1} if Sij
i<k<j and akSij
• How to implement?
– How to compute the initial cases by checking Sij=?
– How to loop to iteratively compute C[i,j]:
– For i=… for j=… for k=…? This is wrong?
– Need to be similar to MCM:
• For len=… for i=… j=i+len; for k=…](https://image.slidesharecdn.com/greedyalgorithms-230219184717-057fdb13/85/GreedyAlgorithms-ppt-4-320.jpg)
![Maximum attendance
• A little bit change to the previous activity selection. For each
activity ai such as a talk, there is an associated attendance atti.
– i.e., given
{a1,a2,…,an}={(s1,f1,att1),(s2,f2,att2),…(sn,fn,attn), compute
its maximum attendance of compatible activities.
• Use the one similar to the previous activity-selection:
• C[i,j]= 0 if Sij=
max{c[i,k]+c[k,j]+attk} if Sij
i<k<j and akSij](https://image.slidesharecdn.com/greedyalgorithms-230219184717-057fdb13/85/GreedyAlgorithms-ppt-11-320.jpg)
GreedyAlgorithms.ppt
- 1. Greedy Algorithms (Chap. 16) • Optimization problems – Dynamic programming, but overkill sometime. – Greedy algorithm: • Being greedy for local optimization with the hope it will lead to a global optimal solution, not always, but in many situations, it works.
- 2. An Activity-Selection Problem • Suppose A set of activities S={a1, a2,…, an} – They use resources, such as lecture hall, one lecture at a time – Each ai, has a start time si, and finish time fi, with 0 si< fi<. – ai and aj are compatible if [si, fi) and [sj, fj) do not overlap • Goal: select maximum-size subset of mutually compatible activities. • Start from dynamic programming, then greedy algorithm, see the relation between the two.
- 3. DP solution –step 1 • Optimal substructure of activity-selection problem. – Furthermore, assume that f1 … fn. – Define Sij={ak: fi sk<fksj}, i.e., all activities starting after ai finished and ending before aj begins. – Define two fictitious activities a0 with f0=0 and an+1 with sn+1= • So f0 f1 … fn+1. – Then an optimal solution including ak to Sij contains within it the optimal solution to Sik and Skj.
- 4. DP solution –step 2 • A recursive solution • Assume c[n+1,n+1] with c[i,j] is the number of activities in a maximum-size subset of mutually compatible activities in Sij. So the solution is c[0,n+1]=S0,n+1. • C[i,j]= 0 if Sij= max{c[i,k]+c[k,j]+1} if Sij i<k<j and akSij • How to implement? – How to compute the initial cases by checking Sij=? – How to loop to iteratively compute C[i,j]: – For i=… for j=… for k=…? This is wrong? – Need to be similar to MCM: • For len=… for i=… j=i+len; for k=…
- 5. Converting DP Solution to Greedy Solution • Theorem 16.1: consider any nonempty subproblem Sij, and let am be the activity in Sij with earliest finish time: fm=min{fk : ak Sij}, then 1. Activity am is used in some maximum-size subset of mutually compatible activities of Sij. 2. The subproblem Sim is empty, so that choosing am leaves Smj as the only one that may be nonempty. • Proof of the theorem:
- 6. Top-Down Rather Than Bottom-Up • To solve Sij, choose am in Sij with the earliest finish time, then solve Smj, (Sim is empty) • It is certain that optimal solution to Smj is in optimal solution to Sij. • No need to solve Smj ahead of Sij. • Subproblem pattern: Si,n+1.
- 7. Optimal Solution Properties • In DP, optimal solution depends: – How many subproblems to divide. (2 subproblems) – How many choices to determine which subproblem to use. (j-i- 1 choices) • However, the above theorem (16.1) reduces both significantly – One subproblem (the other is sure to be empty). – One choice, i.e., the one with earliest finish time in Sij. – Moreover, top-down solving, rather than bottom-up in DP. – Pattern to the subproblems that we solve, Sm,n+1 from Sij. – Pattern to the activities that we choose. The activity with earliest finish time. – With this local optimal, it is in fact the global optimal.
- 8. Elements of greedy strategy • Determine the optimal substructure • Develop the recursive solution • Prove one of the optimal choices is the greedy choice yet safe • Show that all but one of subproblems are empty after greedy choice • Develop a recursive algorithm that implements the greedy strategy • Convert the recursive algorithm to an iterative one.
- 9. Greedy vs. DP • Knapsack problem – I1 (v1,w1), I2(v2,w2),…,In(vn,wn). – Given a weight W at most he can carry, – Find the items which maximize the values • Fractional knapsack, – Greed algorithm, O(nlogn) • 0/1 knapsack. – DP, O(nW). – Questions: 0/1 knapsack is an NP-complete problem, why O(nW) algorithm?
- 10. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display.
- 11. Maximum attendance • A little bit change to the previous activity selection. For each activity ai such as a talk, there is an associated attendance atti. – i.e., given {a1,a2,…,an}={(s1,f1,att1),(s2,f2,att2),…(sn,fn,attn), compute its maximum attendance of compatible activities. • Use the one similar to the previous activity-selection: • C[i,j]= 0 if Sij= max{c[i,k]+c[k,j]+attk} if Sij i<k<j and akSij
- 12. Maximum attendance (cont.) • New analysis (easy to think sort activities): – For any ai, which is the most recent previous one compatible with it? • so, define P(i)=max{k: k<i && fk si}. • compute P(i) is easy. P(1)=0. (for easy coding, a dummy a0=(0,0,0)) – Also, define T(i): the maximum attendance of all compatible activities from a1 to ai. T(n) will be an answer. – Consider activity ai, two cases: • ai is contained within the solution, then only aP(i) can be included too. • ai is not included, then ai-1 can be included. – T(i)= 0 if i=0 max{T(i-1),atti+T(P(i))} if i>0
- 13. Typical tradition problem with greedy solutions • Coin changes – 25, 10, 5, 1 – How about 7, 5, 1 • Minimum Spanning Tree – Prim’s algorithm • Begin from any node, each time add a new node which is closest to the existing subtree. – Kruskal’s algorithm • Sorting the edges by their weights • Each time, add the next edge which will not create cycle after added. • Single source shortest pathes – Dijkstra’s algorithm • Huffman coding • Optimal merge