# Greedy Algorithm in Data Structure

## What is Greedy Algorithm?

Greedy algorithm is a technique used to solve optimization problems by making the best choice at each step in the hope that these choices will eventually lead to the optimal solution. In the context of data structures, a greedy algorithm can be used to solve problems that involve finding the optimal solution among a set of possible solutions.

For example, a common problem that can be solved using a greedy algorithm is the problem of finding the minimum spanning tree of a graph. In this problem, the goal is to find a tree that connects all the vertices of the graph with the minimum total weight. A greedy algorithm for this problem would start by selecting the edge with the smallest weight, then adding the next smallest edge, and so on, until all vertices are connected.

Another example of a problem that can be solved using a greedy algorithm is the activity selection problem. This problem involves selecting a maximum number of non-overlapping activities to perform, given a set of activities with start and end times. The greedy algorithm for this problem would select the activity with the earliest finishing time, then move on to the next activity that starts after that activity ends, and so on, until no more activities can be selected.

It is important to note that not all problems can be solved using a greedy algorithm, and that a greedy algorithm may not always yield the optimal solution. However, for many problems, a greedy algorithm can provide a good approximation to the optimal solution and can be an efficient approach to solve the problem.

## Characteristics of Greedy Algorithm

The following are the main characteristics of greedy algorithms:

• Optimal Local Choice: At each step, a greedy algorithm makes the choice that looks best at that moment, without considering the effect of this choice on future steps. The algorithm makes the locally optimal choice at each step in the hope that these choices will lead to a globally optimal solution.
• Greediness: The name "greedy algorithm" comes from the algorithm's greedy nature, where it makes the best choice available at each step. This means that the algorithm prioritizes finding the immediate solution that appears to be the best, rather than considering the long-term consequences of the choice.
• Irrevocable Choices: Once a choice is made, it is not possible to undo or change it in a greedy algorithm. This means that the algorithm does not have the ability to backtrack or explore other possibilities once it has made a choice.
• No Regret: The greedy algorithm does not have any regret as it always makes the best choice available at the time which gives the information it has.
• Greedy Algorithms are Not Always Optimal: While a greedy algorithm may lead to the optimal solution for some problems, this is not always the case. There are situations where the greedy approach may not yield the optimal solution and other techniques such as dynamic programming or branch and bound may be necessary to solve the problem.
• Efficient: Greedy algorithms can be highly efficient, as they make a constant amount of decisions at each step and do not require searching through all possible solutions. This can make greedy algorithms a good choice for solving problems with large input sizes.

## Why we use Greedy algorithm?

We use greedy algorithms for several reasons:

• Simplicity: Greedy algorithms are relatively simple to understand and implement, compared to other algorithms such as dynamic programming or branch and bound. They are based on a straightforward approach of making the best choice at each step, which makes them easy to follow and understand.
• Efficiency: Greedy algorithms can be highly efficient, as they make a constant amount of decisions at each step and do not require searching through all possible solutions. This can make them a good choice for solving problems with large input sizes.
• Good Approximation: For many optimization problems, a greedy algorithm can provide a good approximation to the optimal solution. Even if the solution produced by a greedy algorithm is not always the optimal solution, it can still be close to the optimal solution and be good enough for many practical purposes.
• Greedy Algorithms can be used as a Building Block: Greedy algorithms can be used as a building block for solving more complex problems. For example, a greedy algorithm can be used to find an initial solution, which can then be improved using other algorithms such as dynamic programming or branch and bound.
• Widely Applicable: Greedy algorithms can be applied to a wide range of problems, including problems in graph theory, scheduling, resource allocation, and many others. This makes them a versatile tool for solving optimization problems.

## Architecture of greedy algorithm

The architecture of a greedy algorithm involves defining the problem, determining the optimization goal, defining the rules for making the greedy choice, making the greedy choice, implementing the choice, repeating the process, and outputting the final solution.

In the first step, the problem to be solved must be defined and the input obtained. The optimization goal is then determined, which could be minimizing the cost, maximizing the profit, finding the shortest path, etc. In the next step, the rules or criteria for making the greedy choice are defined. This involves establishing the rules that will be used to make the best choice at each step, based on the optimization goal.

Once the rules are defined, the algorithm proceeds to make the greedy choice. At each step, the best choice is made based on the rules, without considering the impact of that choice on future steps. The chosen solution is then implemented and the data structures updated to reflect the new state of the problem. The process of making the greedy choice and implementing it is repeated until a solution is reached.

Finally, the final solution is outputted in a suitable form, such as a graph, a set of tasks, or any other representation of the solution. The architecture of a greedy algorithm is focused on making the best choice at each step, without considering the impact of that choice on future steps, in order to find the globally optimal solution.

Let’s take an example of greedy algorithm program:

Example:

``````#include<bits/stdc++.h>
using namespace std;
int minCoins(int coins[], int m, int V)
{
int table[V+1];
table = 0;
for (int i=1; i<=V; i++)
table[i] = INT_MAX;
for (int i=1; i<=V; i++)
{
for (int j=0; j<m; j++)
if (coins[j] <= i)
{
int sub_res = table[i-coins[j]];
if (sub_res != INT_MAX &&sub_res + 1 < table[i])
table[i] = sub_res + 1;
}
}
return table[V];
}

int main()
{
int coins[] = {9, 8, 5, 1};
int m = sizeof(coins)/sizeof(coins);
int V = 11;
cout<< "Minimum coins required is "
<<minCoins(coins, m, V);
return 0;
}
``````

Output:

`Minimum coins required is 3`

Explanation:

In this example, the input is an array of coin values, the number of coins m, and the total value V that we want to make.

The function minCoins uses a dynamic programming approach to find the minimum number of coins required to make the value V. The function uses a table to store the minimum number of coins required to make each value, starting from 0.

The function iterates through the table and updates it with the minimum number of coins required to make each value, using the previously computed values. The final solution is the value in the table at the index V.