Greedy Algorithm Tutorial

Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems. 

An optimization problem can be solved using Greedy if the problem has the following property: 

• At every step, we can make a choice that looks best at the moment, and we get the optimal solution to the complete problem. 
• Some popular Greedy Algorithms are Fractional Knapsack, Dijkstra’s algorithm, Kruskal’s algorithm, Huffman coding and Prim’s Algorithm
• The greedy algorithms are sometimes also used to get an approximation for Hard optimization problems. For example, the Traveling Salesman Problem is an NP-Hard problem. A Greedy choice for this problem is to pick the nearest unvisited city from the current city at every step. These solutions don’t always produce the best optimal solution but can be used to get an approximately optimal solution.

However, it’s important to note that not all problems are suitable for greedy algorithms. They work best when the problem exhibits the following properties:

• Greedy Choice Property: The optimal solution can be constructed by making the best local choice at each step.
• Optimal Substructure: The optimal solution to the problem contains the optimal solutions to its subproblems.

Characteristics of Greedy Algorithm

Here are the characteristics of a greedy algorithm:

• Greedy algorithms are simple and easy to implement.
• They are efficient in terms of time complexity, often providing quick solutions. Greedy Algorithms are typically preferred over Dynamic Programming for the problems where both are applied. For example, Jump Game problem and Single Source Shortest Path Problem (Dijkstra is preferred over Bellman Ford where we do not have negative weights).
• These algorithms do not reconsider previous choices, as they make decisions based on current information without looking ahead.

These characteristics help to define the nature and usage of greedy algorithms in problem-solving.

Want to master Greedy algorithm and more? Check out our DSA Self-Paced Course for a comprehensive guide to Data Structures and Algorithms at your own pace. This course will help you build a strong foundation and advance your problem-solving skills.

How does the Greedy Algorithm works?

Greedy Algorithm solve optimization problems by making the best local choice at each step in the hope of finding the global optimum. It’s like taking the best option available at each moment, hoping it will lead to the best overall outcome.

Here’s how it works:

1. Start with the initial state of the problem. This is the starting point from where you begin making choices.
2. Evaluate all possible choices you can make from the current state. Consider all the options available at that specific moment.
3. Choose the option that seems best at that moment, regardless of future consequences. This is the “greedy” part – you take the best option available now, even if it might not be the best in the long run.
4. Move to the new state based on your chosen option. This becomes your new starting point for the next iteration.
5. Repeat steps 2-4 until you reach the goal state or no further progress is possible. Keep making the best local choices until you reach the end of the problem or get stuck.

Example:

Let’s say you have a set of coins with values [1, 2, 5, 10] and you need to give minimum number of coin to someone change for 39.

The greedy algorithm for making change would work as follows:

• Step-1: Start with the largest coin value that is less than or equal to the amount to be changed. In this case, the largest coin less than or equal to 39 is 10.
• Step- 2: Subtract the largest coin value from the amount to be changed, and add the coin to the solution. In this case, subtracting 10 from 39 gives 29, and we add one 10-coin to the solution.

Repeat steps 1 and 2 until the amount to be changed becomes 0.

Below is the illustration of above example:

1 / 5

// C++ Program to find the minimum number of coins
// to construct a given amount using greedy approach

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int minCoins(vector<int> &coins, int amount) {
    int n = coins.size();
    sort(coins.begin(), coins.end());
    int res = 0;
  
    // Start from the coin with highest denomination
    for(int i = n - 1; i >= 0; i--) {
    	if(amount >= coins[i]) {
          
            // Find the maximum number of ith coin 
            // we can use
            int cnt = (amount / coins[i]);
          
            // Add the count to result
        	res += cnt;
          
            // Subtract the corresponding amount from
            // the total amount
            amount -= (cnt * coins[i]);
        }
      
        // Break if there is no amount left
        if(amount == 0)
            break;
    }
    return res;
}

int main() {
    vector<int> coins = {5, 2, 10, 1};
    int amount = 39;
  
    cout << minCoins(coins, amount);
    return 0;
}

// C Program to find the minimum number of coins
// to construct a given amount using greedy approach

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int *)b - *(int *)a);
}

int minCoins(int coins[], int n, int amount) {
  
    // Sort the coins in descending order
    qsort(coins, n, sizeof(int), compare);
  
    int res = 0;
  
    // Start from the coin with highest denomination
    for(int i = 0; i < n; i++) {
        if(amount >= coins[i]) {
          
            // Find the maximum number of ith coin 
            // we can use
            int cnt = (amount / coins[i]);
          
            // Add the count to result
            res += cnt;
          
            // Subtract the corresponding amount from
            // the total amount
            amount -= (cnt * coins[i]);
        }
      
        // Break if there is no amount left
        if(amount == 0)
            break;
    }
    return res;
}

int main() {
    int coins[] = {5, 2, 10, 1};
    int n = sizeof(coins) / sizeof(coins[0]);
    int amount = 39;
  
    printf("%d", minCoins(coins, n, amount));
    return 0;
}

// Java Program to find the minimum number of coins
// to construct a given amount using greedy approach

import java.util.Arrays;

class GfG {
    static int minCoins(int[] coins, int amount) {
        int n = coins.length;
        Arrays.sort(coins);  
        int res = 0;
        
        // Start from the coin with highest denomination
        for (int i = n - 1; i >= 0; i--) {
            if (amount >= coins[i]) {
              
                // Find the maximum number of ith coin we can use
                int cnt = (amount / coins[i]);
                
                // Add the count to result
                res += cnt;
                
                // Subtract the corresponding amount from 
                // the total amount
                amount -= (cnt * coins[i]);
            }
            
            // Break if there is no amount left
            if (amount == 0)
                break;
        }
        return res;
    }

    public static void main(String[] args) {
        int[] coins = {5, 2, 10, 1};
        int amount = 39;
      
        System.out.println(minCoins(coins, amount));
    }
}

# Python Program to find the minimum number of coins
# to construct a given amount using greedy approach

def minCoins(coins, amount):
    n = len(coins)
    coins.sort()
    res = 0

    # Start from the coin with highest denomination
    for i in range(n - 1, -1, -1):
        if amount >= coins[i]:
          
            # Find the maximum number of ith coin we can use
            cnt = amount // coins[i]

            # Add the count to result
            res += cnt

            # Subtract the corresponding amount from the total amount
            amount -= cnt * coins[i]

        # Break if there is no amount left
        if amount == 0:
            break
    return res

if __name__ == "__main__":
    coins = [5, 2, 10, 1]
    amount = 39

    print(minCoins(coins, amount))

// C# Program to find the minimum number of coins
// to construct a given amount using greedy approach

using System;

class GfG {
    static int minCoins(int[] coins, int amount) {
        int n = coins.Length;
        Array.Sort(coins); 
        int res = 0;

        // Start from the coin with highest denomination
        for (int i = n - 1; i >= 0; i--) {
            if (amount >= coins[i]) {
              
                // Find the maximum number of ith coin we can use
                int cnt = (amount / coins[i]);

                // Add the count to result
                res += cnt;

                // Subtract the corresponding amount from the total amount
                amount -= (cnt * coins[i]);
            }

            // Break if there is no amount left
            if (amount == 0)
                break;
        }
        return res;
    }

    static void Main() {
        int[] coins = { 5, 2, 10, 1 };
        int amount = 39;
      
        Console.WriteLine(minCoins(coins, amount));
    }
}

// JavaScript Program to find the minimum number of coins
// to construct a given amount using greedy approach

function minCoins(coins, amount) {
    let n = coins.length;
    coins.sort((a, b) => a - b); 
    let res = 0;

    // Start from the coin with highest denomination
    for (let i = n - 1; i >= 0; i--) {
        if (amount >= coins[i]) {

            // Find the maximum number of ith coin we can use
            let cnt = Math.floor(amount / coins[i]);

            // Add the count to result
            res += cnt;

            // Subtract the corresponding amount from the total amount
            amount -= (cnt * coins[i]);
        }

        // Break if there is no amount left
        if (amount === 0)
            break;
    }
    return res;
}

// Driver code
let coins = [5, 2, 10, 1];
let amount = 39;

console.log(minCoins(coins, amount));

6

The greedy algorithm is not always the optimal solution for every optimization problem, as shown in the example below.

• When using the greedy approach to make change for the amount 20 with the coin denominations [18, 1, 10], the algorithm starts by selecting the largest coin value that is less than or equal to the target amount. In this case, the largest coin is 18, so the algorithm selects one 18 coin. After subtracting 18 from 20, the remaining amount is 2.
• At this point, the greedy algorithm chooses the next largest coin less than or equal to 2, which is 1. It then selects two 1 coins to make up the remaining amount. So, the greedy approach results in using one 18 coin and two 1 coins.

However, the greedy approach fails to find the optimal solution in this case. Although it uses three coins, a better solution would have been to use two 10 coins, resulting in a total of only two coins (10 + 10 = 20).

Related Articles:

• Greedy Algorithms General Structure
• Top 20 Greedy Algorithms Interview Questions
• Most recent published articles on Greedy Algorithm
• Practice problems on Greedy Algorithms

kartik

Follow

Improve

Article Tags :

• DSA
• GBlog
• Greedy
• Algorithms-Greedy Algorithms
• DSA Tutorials
• GBlog 2024
• Greedy Algorithms
• Tutorials

+4 More

Practice Tags :

• Greedy