Greedy Algorithms: A Short Introduction and Examples, Exercises of Verilog and VHDL

Download Greedy Algorithms: A Short Introduction and Examples and more Exercises Verilog and VHDL in PDF only on Docsity!

Greedy Algorithms

2

A short list of categories



Algorithm types we will consider include:



Simple recursive algorithms



Backtracking algorithms



Divide and conquer algorithms



Dynamic programming algorithms



Greedy algorithms



Branch and bound algorithms



Brute force algorithms



Randomized algorithms

4

Example: Counting money



Suppose you want to count out a certain amount of

money, using the fewest possible bills and coins



A greedy algorithm would do this would be:

At each step, take the largest possible bill or coin

that does not overshoot



Example: To make $6.39, you can choose:



a $5 bill



a $1 bill, to make $



a 25¢ coin, to make $6.



A 10¢ coin, to make $6.



four 1¢ coins, to make $6.



For US money, the greedy algorithm always gives

the optimum solution

5

A failure of the greedy algorithm



In some (fictional) monetary system, “krons” come

in 1 kron, 7 kron, and 10 kron coins



Using a greedy algorithm to count out 15 krons,

you would get



A 10 kron piece



Five 1 kron pieces, for a total of 15 krons



This requires six coins



A better solution would be to use two 7 kron pieces

and one 1 kron piece



This only requires three coins



The greedy algorithm results in a solution, but not

in an optimal solution

7

Another approach



What would be the result if you ran the shortest job first?



Again, the running times are 3 , 5 , 6 , 10 , 11 , 14 , 15 , 18 , and

20 minutes



That wasn’t such a good idea; time to completion is now

6 + 14 + 20 = 40 minutes



Note, however, that the greedy algorithm itself is fast



All we had to do at each stage was pick the minimum or maximum

P

P

P

8

An optimum solution



This solution is clearly optimal (why?)



Clearly, there are other optimal solutions (why?)



How do we find such a solution?



One way: Try all possible assignments of jobs to processors



Unfortunately, this approach can take exponential time



Better solutions do exist:

P

P

P

10

Minimum spanning tree



A minimum spanning tree is a least-cost subset of the edges of a

graph that connects all the nodes



Start by picking any node and adding it to the tree



Repeatedly: Pick any least-cost edge from a node in the tree to

a node not in the tree, and add the edge and new node to the

tree



Stop when all nodes have been added to the tree



The result is a least-cost

(3+3+2+2+2=12) spanning tree



If you think some other edge should be in

the spanning tree:



Try adding that edge



Note that the edge is part of a cycle



To break the cycle, you must remove

the edge with the greatest cost



This will be the edge you just

added

3

3

3

3

2

2

2

4

4

4

11

Traveling salesman



A salesman must visit every city (starting from city A ), and wants

to cover the least possible distance



He can revisit a city (and reuse a road) if necessary



He does this by using a greedy algorithm: He goes to the next

nearest city from wherever he is



From A he goes to B



From B he goes to D



This is not going to result in a

shortest path!



The best result he can get now

will be ABDBCE , at a cost of 16



An actual least-cost path from A

is ADBCE , at a cost of 14

E

A B C

D

2

3 3

4

4 4

13

Other greedy algorithms



Dijkstra’s algorithm for finding the shortest path in a

graph



Always takes the shortest edge connecting a known node to

an unknown node



Kruskal’s algorithm for finding a minimum-cost

spanning tree



Always tries the lowest-cost remaining edge



Prim’s algorithm for finding a minimum-cost spanning

tree



Always takes the lowest-cost edge between nodes in the

spanning tree and nodes not yet in the spanning tree

14

Dijkstra’s shortest-path algorithm



Dijkstra’s algorithm finds the shortest paths from a given node to

all other nodes in a graph



Initially,



Mark the given node as known (path length is zero)



For each out-edge, set the distance in each neighboring node equal to the cost

(length) of the out-edge, and set its predecessor to the initially given node



Repeatedly (until all nodes are known),



Find an unknown node containing the smallest distance



Mark the new node as known



For each node adjacent to the new node, examine its neighbors to see whether

their estimated distance can be reduced (distance to known node plus cost of

out-edge)



If so, also reset the predecessor of the new node

16

Analysis of Dijkstra’s algorithm II



Repeatedly (until all nodes are known), (n times)



Find an unknown node containing the smallest distance



Probably the best way to do this is to put the unknown nodes into a

priority queue; this takes k * O(log n) time each time a new node is

marked “known” (and this happens n times)



Mark the new node as known -- O(1) time



For each node adjacent to the new node, examine its neighbors to

see whether their estimated distance can be reduced (distance to

known node plus cost of out-edge)



If so, also reset the predecessor of the new node



There are k adjacent nodes (on average), operation requires constant

time at each, therefore O(k) (constant) time



Combining all the parts, we get:

O(1) + n(kO(log n)+O(k)), that is, O(nk log n) time

17

Connecting wires



There are n white dots and n black dots, equally spaced, in a line



You want to connect each white dot with some one black dot,

with a minimum total length of “wire”



Example:



Total wire length above is 1 + 1 + 1 + 5 = 8



Do you see a greedy algorithm for doing this?



Does the algorithm guarantee an optimal solution?



Can you prove it?



Can you find a counterexample?

19

The End