# Greedy algorithm

This article needs additional citations for verification. (September 2018) (Learn how and when to remove this template message) |

A **greedy algorithm** is an algorithmic paradigm that follows the problem solving heuristic of making the locally optimal choice at each stage^{[1]} with the intent of finding a global optimum. In many problems, a greedy strategy does not usually produce an optimal solution, but nonetheless a greedy heuristic may yield locally optimal solutions that approximate a globally optimal solution in a reasonable amount of time.

For example, a greedy strategy for the traveling salesman problem (which is of a high computational complexity) is the following heuristic: "At each step of the journey, visit the nearest unvisited city." This heuristic does not intend to find a best solution, but it terminates in a reasonable number of steps; finding an optimal solution to such a complex problem typically requires unreasonably many steps. In mathematical optimization, greedy algorithms optimally solve combinatorial problems having the properties of matroids, and give constant-factor approximations to optimization problems with submodular structure.

## Contents

## Specifics[edit]

In general, greedy algorithms have five components:

- A candidate set, from which a solution is created
- A selection function, which chooses the best candidate to be added to the solution
- A feasibility function, that is used to determine if a candidate can be used to contribute to a solution
- An objective function, which assigns a value to a solution, or a partial solution, and
- A solution function, which will indicate when we have discovered a complete solution

Greedy algorithms produce good solutions on some mathematical problems, but not on others. Most problems for which they work will have two properties:

- Greedy choice property
- We can make whatever choice seems best at the moment and then solve the subproblems that arise later. The choice made by a greedy algorithm may depend on choices made so far, but not on future choices or all the solutions to the subproblem, it iteratively makes one greedy choice after another, reducing each given problem into a smaller one. In other words, a greedy algorithm never reconsiders its choices; this is the main difference from dynamic programming, which is exhaustive and is guaranteed to find the solution. After every stage, dynamic programming makes decisions based on all the decisions made in the previous stage, and may reconsider the previous stage's algorithmic path to solution.

- Optimal substructure
- "A problem exhibits optimal substructure if an optimal solution to the problem contains optimal solutions to the sub-problems."
^{[2]}

### Cases of failure[edit]

For many other problems, greedy algorithms fail to produce the optimal solution, and may even produce the *unique worst possible* solution. One example is the traveling salesman problem mentioned above: for each number of cities, there is an assignment of distances between the cities for which the nearest-neighbor heuristic produces the unique worst possible tour.^{[3]}

## Types[edit]

This section needs additional citations for verification. (June 2018) (Learn how and when to remove this template message) |

Greedy algorithms can be characterized as being 'short sighted', and also as 'non-recoverable', they are ideal only for problems which have 'optimal substructure'. Despite this, for many simple problems, the best suited algorithms are greedy algorithms, it is important, however, to note that the greedy algorithm can be used as a selection algorithm to prioritize options within a search, or branch-and-bound algorithm. There are a few variations to the greedy algorithm:

- Pure greedy algorithms
- Orthogonal greedy algorithms
- Relaxed greedy algorithms

## Theory[edit]

Greedy algorithms have a long history of study in combinatorial optimization and theoretical computer science. Greedy heuristics are known to produce suboptimal results on many problems,^{[4]} and so natural questions are:

- For which problems do greedy algorithms perform optimally?
- For which problems do greedy algorithms guarantee an approximately optimal solution?
- For which problems is the greedy algorithm guaranteed
*not*to produce an optimal solution?

A large body of literature exists answering these questions for general classes of problems, such as matroids, as well as for specific problems, such as set cover.

### Matroids[edit]

A matroid is a mathematical structure that generalizes the notion of linear independence from vector spaces to arbitrary sets. If an optimization problem has the structure of a matroid, then the appropriate greedy algorithm will solve it optimally.^{[5]}

### Submodular functions[edit]

A function defined on subsets of a set is called submodular if for every we have that .

Suppose one wants to find a set which maximizes . The greedy algorithm, which builds up a set by incrementally adding the element which increases the most at each step, produces as output a set that is at least .^{[6]} That is, greedy performs within a constant factor of as good as the optimal solution.

Similar guarantees are provable when additional constraints, such as cardinality constraints,^{[7]} are imposed on the output, though often slight variations on the greedy algorithm are required. See ^{[8]} for an overview.

### Other problems with guarantees[edit]

Other problems for which the greedy algorithm gives a strong guarantee, but not an optimal solution, include

Many of these problems have matching lower bounds; i.e., the greedy algorithm does not perform better, in the worst case, than the guarantee.

## Applications[edit]

Greedy algorithms mostly (but not always) fail to find the globally optimal solution because they usually do not operate exhaustively on all the data, they can make commitments to certain choices too early which prevent them from finding the best overall solution later. For example, all known greedy coloring algorithms for the graph coloring problem and all other NP-complete problems do not consistently find optimum solutions. Nevertheless, they are useful because they are quick to think up and often give good approximations to the optimum.

If a greedy algorithm can be proven to yield the global optimum for a given problem class, it typically becomes the method of choice because it is faster than other optimization methods like dynamic programming. Examples of such greedy algorithms are Kruskal's algorithm and Prim's algorithm for finding minimum spanning trees, and the algorithm for finding optimum Huffman trees.

Greedy algorithms appear in network routing as well. Using greedy routing, a message is forwarded to the neighboring node which is "closest" to the destination; the notion of a node's location (and hence "closeness") may be determined by its physical location, as in geographic routing used by ad hoc networks. Location may also be an entirely artificial construct as in small world routing and distributed hash table.

## Examples[edit]

- The activity selection problem is characteristic to this class of problems, where the goal is to pick the maximum number of activities that do not clash with each other.
- In the Macintosh computer game
*Crystal Quest*the objective is to collect crystals, in a fashion similar to the travelling salesman problem. The game has a demo mode, where the game uses a greedy algorithm to go to every crystal; the artificial intelligence does not account for obstacles, so the demo mode often ends quickly. - The matching pursuit is an example of greedy algorithm applied on signal approximation.
- A greedy algorithm finds the optimal solution to Malfatti's problem of finding three disjoint circles within a given triangle that maximize the total area of the circles; it is conjectured that the same greedy algorithm is optimal for any number of circles.
- A greedy algorithm is used to construct a Huffman tree during Huffman coding where it finds an optimal solution.
- In decision tree learning, greedy algorithms are commonly used, however they are not guaranteed to find the optimal solution.
- One popular such algorithm is the ID3 algorithm for decision tree construction.

- Dijkstra's algorithm and the related A* search algorithm are verifiably optimal greedy algorithms for graph search and shortest path finding.
- A* search is conditionally optimal, requiring an "admissible heuristic" that will not overestimate path costs.

- Kruskal's algorithm and Prim's algorithm are greedy algorithms for constructing minimum spanning trees of a given connected graph. They always find an optimal solution, which may not be unique in general.

## See also[edit]

## Notes[edit]

**^**Black, Paul E. (2 February 2005). "greedy algorithm".*Dictionary of Algorithms and Data Structures*. U.S. National Institute of Standards and Technology (NIST). Retrieved 17 August 2012.**^**Introduction to Algorithms (Cormen, Leiserson, Rivest, and Stein) 2001, Chapter 16 "Greedy Algorithms".**^**Traveling salesman should not be greedy: domination analysis of greedy-type heuristics for the TSP (G. Gutin, A. Yeo and A. Zverovich, 2002)**^**U. Feige. A threshold of ln n for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998.**^**Papadimitriou, Christos H., and Kenneth Steiglitz. Combinatorial optimization: algorithms and complexity. Courier Corporation, 1998.**^**G. Nemhauser, L.A. Wolsey, and M.L. Fisher. "An analysis of approximations for maximizing submodular set functions—I." Mathematical Programming 14.1 (1978): 265-294.**^**N. Buchbinder, et al. "Submodular maximization with cardinality constraints." Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms. Society for Industrial and Applied Mathematics, 2014.**^**Krause, Andreas, and Daniel Golovin. "Submodular function maximization." (2014): 71-104.**^**http://www.win.tue.nl/~mdberg/Onderwijs/AdvAlg_Material/Course%20Notes/lecture5.pdf

## References[edit]

*Introduction to Algorithms*(Cormen, Leiserson, Rivest, and Stein) 2001, Chapter 16 "Greedy Algorithms".- G. Gutin, A. Yeo and A. Zverovich, Traveling salesman should not be greedy: domination analysis of greedy-type heuristics for the TSP. Discrete Applied Mathematics 117 (2002), 81–86.
- J. Bang-Jensen, G. Gutin and A. Yeo, When the greedy algorithm fails. Discrete Optimization 1 (2004), 121–127.
- G. Bendall and F. Margot, Greedy Type Resistance of Combinatorial Problems, Discrete Optimization 3 (2006), 288–298.
- U. Feige. A threshold of ln n for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998.
- G. Nemhauser, L.A. Wolsey, and M.L. Fisher. "An analysis of approximations for maximizing submodular set functions—I." Mathematical Programming 14.1 (1978): 265-294.
- N. Buchbinder, et al. "Submodular maximization with cardinality constraints." Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms. Society for Industrial and Applied Mathematics, 2014.
- A. Krause and D. Golovin. "Submodular function maximization." (2014): 71-104.

## External links[edit]

Wikimedia Commons has media related to .Greedy algorithms |

- Hazewinkel, Michiel, ed. (2001) [1994], "Greedy algorithm",
*Encyclopedia of Mathematics*, Springer Science+Business Media B.V. / Kluwer Academic Publishers, ISBN 978-1-55608-010-4 - Python greedy coin example by Noah Gift.