Greedy Algorithms

1. CHAPTER 7 Greedy Algorithms

2. Algorithm 7.1.1 Greedy Coin Changing This algorithm makes change for an amount A using coins of denominations denom[1] > denom[2] > ··· > denom[n] = 1. Input Parameters: denom,A Output Parameters: None greedy_coin_change(denom,A) { i = 1 while (A > 0) { c = A/denom[i] println(“use ” + c + “ coins of denomination ” + denom[i]) A = A - c * denom[i] i = i + 1 } }

3. Algorithm 7.2.4 Kruskal’s Algorithm Kruskal’s algorithm finds a minimal spanning tree in a connected, weighted graph with vertex set {1, ... , n} . The input to the algorithm is edgelist, an array of edge, and n. The members of edge are • v and w, the vertices on which the edge is incident. • weight, the weight of the edge. The output lists the edges in a minimal spanning tree. The function sort sorts the array edgelist in nondecreasing order of weight.

4. Input Parameters: edgelist,n Output Parameters: None kruskal(edgelist,n) { sort(edgelist) for i = 1 to n makeset(i) count = 0 i = 1 while (count < n - 1) { if (findset(edgelist[i].v) != findset(edgelist[i].w)) { println(edgelist[i].v + “ ” + edgelist[i].w) count = count + 1 union(edgelist[i].v,edgelist[i].w) } i = i + 1 } }

5. Algorithm 7.3.4 Prim’s Algorithm This algorithm finds a minimal spanning tree in a connected, weighted, n-vertex graph. The graph is represented using adjacency lists; adj[i] is a reference to the first node in a linked list of nodes representing the vertices adjacent to vertex i. Each node has members ver, the vertex adjacent to i; weight, representing the weight of edge (i,ver); and next, a reference to the next node in the linked list or null, for the last node in the linked list. The start vertex is start. In the minimal spanning tree, the parent of vertex i≠start is parent[i], and parent[start] = 0. The value ∞ is the largest available integer value.

6. Input Parameters: adj,start Output Parameters: parent prim(adj,start,parent) { n = adj.last for i = 1 to n key[i] = ∞ // key is a local array key[start] = 0 parent[start] = 0 // the following statement initializes the // container h to the values in the array key h.init(key,n) for i = 1 to n { v = h.del() ref = adj[v] while (ref != null) { w = ref.ver if (h.isin(w) && ref.weight < h.keyval(w)) { parent[w] = v h.decrease(w,ref.weight) } ref = ref.next } } }

7. Algorithm 7.4.4 Dijkstra’s Algorithm This algorithm finds shortest paths from the designated vertex start to all of the other vertices in a connected, weighted, n-vertex graph. The graph is represented using adjacency lists; adj[i] is a reference to the first node in a linked list of nodes representing the vertices adjacent to vertex i. Each node has members ver, the vertex adjacent to i; weight, representing the weight of edge (i,ver); and next, a reference to the next node in the linked list or null, for the last node in the linked list. In a shortest path, the predecessor of vertex i start is predecessor[i], and predecessor[start] = 0. The value ∞ is the largest available integer value. The abstract data type h supports the same operations as in Prim’s algorithm.

8. Input Parameters: adj,start Output Parameters: parent dijkstra(adj,start,parent) { n = adj.last for i = 1 to n key[i] = ∞ // key is a local array key[start] = 0 predecessor[start] = 0 ...

9. ... // the following statement initializes the // container h to the values in the array key h.init(key,n) for i = 1 to n { v = h.min_weight_index() min_cost = h.keyval(v) v = h.del() ref = adj[v] while (ref != null) { w = ref.ver if (h.isin(w) && min_cost + ref.weight < h.keyval(w)) { predecessor[w] = v h.decrease(w, min_cost+ref.weight) } // end if ref = ref.next } // end while } // end for }

10. Algorithm 7.5.3 Huffman’s Algorithm This algorithm constructs an optimal Huffman coding tree. The input is an array a of n = 2 nodes. Each node has an integer member character to identify a particular character, another integer member key to identify that character’s frequency, and left and right members. After the Huffman coding tree is constructed, a left member of a node references its left child, and a right member of a node references its right child or, if the node is a terminal vertex, its left and right members are null. The algorithm returns a reference to the root of the Huffman coding tree. The operator, new, is used to obtain a new node. If a is an array, the expression h.init(a) initializes the container h to the data in a. The expression h.del() deletes the node in h with the smallest key and returns the node. The expression h.insert(ref ) inserts the node referenced by ref into h.

11. Input Parameters: a Output Parameters: None huffman(a) { h.init(a) for i = 1 to a.last - 1 { ref = new node ref.left = h.del() ref.right = h.del() ref.key = ref.left.key + ref.right.key h.insert(ref) } return h.del() }

12. Algorithm 7.6.2 Greedy Algorithm for the Continuous-Knapsack Problem The input to the algorithm is the knapsack capacity C, and an array a of size n, each of whose entries specifies an id (e.g., the first item might have id 1, the second item might have id 2, etc.), a profit p, and a weight w. The output tells how much of each object to select to maximize the profit. Objects not selected do not appear in the output. The function sort sorts the array a in nonincreasing order of the ratio of profit to weight.

13. Input Parameters: a,C Output Parameters: None continuous_knapsack(a,C) { n = a.last for i = 1 to n ratio[i] = a[i].p/a[i].w sort(a,ratio) weight = 0 i = 1 while (i ≤ n && weight < C) { if (weight + a[i].w = C) { println(“select all of object ” + a[i].id) weight = weight + a[i].w } else { r = (C - weight)/a[i].w println(“select ” + r + “ of object ” + a[i].id) weight = C } i = i + 1 } }