Greedy
Algorithms
Greedy Algorithms are one of the most intuitive algorithms. Whenever
we see a problem we first try to apply some greedy strategy to get the
answer(we humans are greedy, aren’t we :P ? ).
Greedy approaches are quite simple and easy to
understand/formulate.But many times the proving part might be
difficult.
Greedy Algorithm always makes the choice that looks best at
the moment.
You hope that by choosing a local optimum ateach step, you
will end up at a global optimum.
Counting Money
Problem Statement: Suppose you want to count out a certain amount
of money,using the fewest possible notes or coins.
Greedy Approach:
At each step, take the largest possible note or coin that does not
overshoot the sum of money and include it in the solution.
Example:
To make Rs 39 with fewest possible notes or coins.
Rs 10 note, to make 29
Rs 10 note, to make 19
Rs 10 note, to make 9
Rs 5 note, to make 4
Rs 2 coin, to make 2
Rs 2 coin, to make 0
Total is 4 notes and 2 coins, which is the optimum solution.
Note: For Indian currency, the greedy algorithm, even after
Demonetization always gives the optimum solution.
Is this true for any currency?
Now that Donald Trump is the new President of US, he decides to do
something extraordinary like PM Modi. So he decides to change all the
currency notes to 1 dollars, 7 dollars and 10 dollars.
Suppose you went to US and used the same greedy approach to count
minimum numbers of notes and coins in exchange for a Burger which
costs $15.
To make $15:
1 $10 note
5 $1 notes
Total = 6 notes
Can we do better than 6?
$7 + $7 +$1 – Only 3 notes required!
Reason?
An Activity Selection Problem
(Conference Scheduling Problem)
Ques. BusyMan
http://www.spoj.com/problems/BUSYMAN/
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct cmpr{
bool operator()(pair<int,int> l, pair<int,int> r){
return l.second < r.second;
}cmp;
int main(){
int t,n,s,e,res;
scanf("%d",&t);
while(t--){
res = 1;
vector<pair<int,int> > activity;
scanf("%d",&n);
for(int i = 0;i<n;i++){
scanf("%d %d",&s,&e);
activity.push_back(make_pair(s,e));
//Sort the activities according to their finish t
ime
sort(activity.begin(),activity.end(),cmp);
//fin denotes the finish time of the choosen acti
vity
//i.e. activity with least finish time
int fin = activity[0].second;
for(int i = 1;i<activity.size();i++){
//To find the next compatible activity with
//least finish time
//Find the first activity whose start time
//is more than finish time of previous activi
ty
if(activity[i].first >= fin){
//update the finish time as the finish ti
me
//of this activity
fin = activity[i].second;
//Since we have choosen a new activity,
//increment the count by 1
res++;
printf("%d\n",res);
return 0;
Fractional Knapsack
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”.
Greedy Approach: Suppose you have a sorted list of the white dot
positions and the black dot positions. Then you should match the i-th
white dot with the i-th black dot.
Why should greedy work?
Let b0 and w0 be the first black and white balls respectively and let bi
and wj be the next white and black balls.
Case 1: w0 and wj < b0
b0 bi
w0 wj
(i) C(w0, bi) + C(wj, b0) = (bi - w0) + (b0 - wj)
(ii) C(w0, b0) + C(wi, bj) = (b0 - w0) + (bi - wj)
Both are same.
Case 2: w0 < b0 and b0 < wj < bi
b0 bi
w0 wj
(i) C(w0, bi) + C(wj, b0) = (bi - w0) + (wj - b0)
(ii) C(w0, b0) + C(wi, bj) = (b0 - w0) + (bi - wj)
(i) - (ii) = 2(wj - b0) is extra
Case 3: w0 < b0 and bi < wj
b0 bi
w0 wj
(i) C(w0, bi) + C(wj, b0) = (bi - w0) + (wj - b0)
(ii) C(w0, b0) + C(wi, bj) = (b0 - w0) + (wj - bi)
(i) - (ii) = 2(bi - b0) is extra
Hence, in all the cases connecting 1st b to 1st w and 2nd b to 2nd w
yeilds more optimal solution.
Ques: Biased Standings
In a competition, each team is be able to enter their preferred place in
the ranklist. Suppose that we already have a ranklist. For each team,
compute the distance between their preferred place and their place in
the ranklist. The sum of these distances will be called the badness of
this ranklist. Find one ranklist with the minimal possible badness.
http://www.spoj.com/problems/BAISED/
This is question is similar to the connecting wires problem, where the
dseired ranks denote the black balls and the actual ranks denote the
white balls. Hence, we can apply the greedy approach by sorting the
desired ranks and calculating the distance between i-th desired rank
and i-th actula rank.
Code
#include <bits/stdc++.h>
using namespace std;
#define abs(a,b) a > b ? a - b : b - a
#define ll long long
int main()
int t;
cin>>t;
while(t--)
vector<int> v;
string name;
ll sum=0;
cin>>n;
for(int i=0;i<n;i++)
cin>>name;
cin>>temp;
//Insert the desired rank in vector v
v.push_back(temp);
//Sort the vector containing the ranks
sort(v.begin(),v.end());
//This is the greedy approach
for(int i=1;i<=n;i++)
//Take the difference between the i-th actual
rank
//and the i-th desired rank
sum += abs(v[i-1],i);
printf("%lld\n",sum);
return 0;
T = O(nlogn)
Can we do better?
#include <bits/stdc++.h>
using namespace std;
#define abs(a,b) a > b ? a - b : b - a
#define ll long long
int arr[100000+10];
int main()
int t,n,temp;
cin>>t;
while(t--)
memset(arr,0,sizeof arr);
string name;
ll sum=0;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>name;
cin>>temp;
//Increment the desired rank index in array a
rr
arr[temp]++;
int pos = 1;
//This is the greedy approach
for(int i=1;i<=n;i++)
//If the i-th rank was desired by atleast one
team
//Assign and increment the actual rank index
'pos'
//till this rank is desired
while(arr[i]){
sum += abs(pos,i);
arr[i]--;
pos++;
printf("%lld\n",sum);
return 0;
}
T = O(n)
Ques. Load Balancer
Rebalancing proceeds in rounds. In each round, every processor can
transfer at most one job to each of its neighbors on the bus. Neighbors
of the processor i are the processors i-1 and i+1 (processors 1 and N
have only one neighbor each, 2 and N-1 respectively). The goal of
rebalancing is to achieve that all processors have the same number of
jobs.Determine the minimal number of rounds needed to achieve the
state when every processor has the same number of jobs, or to
determine that such rebalancing is not possible.
http://www.spoj.com/problems/BALIFE/
Greedy Approach: First find the final load that each processor will
have. We can find it by sum(arr[1], arr[2],…,arr[n])/n, let us call it
load.
So in the final state, each of the processor will have final load = load.
For each index i from 1 to n-1, create a partition of (1…i) and (i+1…n)
and find the amount of load that is to be shared between these two
partitions. The answer will be maximum of all the loads shared
between all the partitions with i varying from 1 to n-1.
Example
Initial state: 4, 8, 12, 16
Final state: 10 10 10 10
i = 1:
partition: (4) (8,12,16)
Load --> (4) needs 6 and (8,12,16) needs to give 6.
max_load = 6
i = 2:
partition: (4,8) (12,16)
Load--> (4,8) needs 8 and (12,16) needs to give 8.
max_laod = 8
i = 3:
partition: (4,8,12) (16)
Load--> (4,8,12) needs 6 and (16) needs to give 6.
max_laod = 6
Final answer = 8
Why does it works?
In all the partitions where less than max_load is transferred, we can
internally transfer the load between these partitions when max_laod is
being transferred between the max_load partition.
t = 2s:
when load = 2 is transferred between (4,8) and (12,16
we can transfer load = 2 between (8) --> (4) and (16)
--> (12)
State: 6 8 12 14
t = 4s:
when load = 2 is transferred between (6,8) and (12,14
we can transfer load = 2 between (8) --> (6) and (14)
--> (12)
State: 8 8 12 12
t = 6s:
when load = 2 is transferred between (8,8) and (12,12
State: 8 10 10 12
t = 8s:
when load = 2 is transferred between (8,10) and (10,1
2)
we can transfer load = 2 between (10) --> (8) and (12
) --> (10)
State: 10 10 10 10
Code
#include <bits/stdc++.h>
using namespace std;
int main()
int arr[9000],n, i, val, diff;
while(1)
int max_load = 0, load = 0;
cin>>n;
if(n == -1)
break;
for(int i = 0;i<n;i++){
cin>>arr[i];
load += arr[i];
//If we cannot divide the load equally
if(load % n){
cout<<-1<<endl;
continue;
//Find the load that is to be divided equally
load /= n;
//Greedy step
for(int i = 0;i<n;i++){
//At each iteration, find the value
//of difference between final load to be assi
gned
//and current load
//Keep adding this difference in 'diff'
diff += (arr[i] - load);
//If the net difference is negative i.e.
//we need diff amount till i-th index
if(diff < 0)
max_load = max(max_load, -1*diff);
//If diff is positive i.e. we have to
//give diff amout to (n-i) processors
else
max_load = max(max_load, diff);
//calculate the max of load that can be given
or
//taken at each iteration
cout<<max_load<<endl;
return 0;
T = O(n)
Ques. Defense of a Kingdom
http://www.spoj.com/problems/DEFKIN/
Greedy Approach: Given w, h as width and height of the playing field,
and the coordinates of the towers as (x1,y1) … (xN,yN), split the
coordinates into two lists x1…xN, y1…yN, sort both of those coordinate
lists.
Then calculate the empty spaces, e.g. dx[] = { x1, x2-x1, …, xN - xN-1,
(w + 1) - xN }. Do the same for the y coordinates: dy[] = { y1, y2-y1,
…, yN - yN-1, (h + 1) - yN }. Multiply max(dx)-1 by max(dy)-1 and you
should have the largest uncovered rectangle. You have to decrement
the delta values by one because the line covered by the higher
coordinate tower is included in it, but it is not uncovered.
Code
#include<iostream>
#include<algorithm>
using namespace std;
int point_x[40000+10], point_y[40000+10];
int main(){
int t,w,h,n,x,y;
scanf("%d",&t);
while(t--){
scanf("%d %d %d",&w,&h,&n);
for(int i = 0;i<n;i++){
scanf("%d %d",&point_x[i],&point_y[i]);
//sort the x-coordinates of the list
sort(point_x, point_x + n);
//sort the y-coordinates of the list
sort(point_y, point_y + n);
//dx --> maximum uncovered tiles in x coordinate
//dy --> maximum uncocered tiles in y coordinate
//Initially dx and dy are the first guars's posit
ion
int dx = point_x[0],dy = point_y[0];
//calculate the maximum uncovered gap
//in x and y coordinate
for(int i = 1;i<n;i++){
dx = max(dx,point_x[i] - point_x[i-1]);
dy = max(dy,point_y[i] - point_y[i-1]);
dx = max(dx, w + 1 - point_x[n-1]);
dy = max(dy, h + 1 - point_y[n-1]);
printf("%d\n",((dx-1) * (dy-1)));
return 0;
}
T = O(nlogn)
Ques. Chopsticks
Given N sticks of length L[1], L[2], …, L[N] and a positive integer D.
Two sticks can be paired if the difference of their length is at most D.
Find the max number of pairs.
https://www.codechef.com/problems/TACHSTCK
Greedy Appraoch:
Sort the list of sticks according to their lengths.
If L[1] and L[2] cannot be paired, L[1] is useless.
Else pair L[1] and L[2] and remove them from the list.
Repeat steps 2-3 till the list become empty.
Why does this works?
By pairing starting stick to its immediate next, we have max
number of options left for next pairing.
If L[1] and L[2] can be paired, but instead we pair (L[1], L[M])
and (L[2], L[N]).
Case 1: L[N] < L[M]
L[1] L[2] L[N] L[M]
L[M] - L[1] <= D
L[N] - L[2] <= D
L[M] - L[1] = (L[M] - L[N]) + (L[N] - L[1])
(L[M] - L[N]) + (+ve number) <= D
L[M] - L[N] <= D
Hence, we can also pair L[N] and L[M]
Case 2: L[N] > L[M]
L[1] L[2] L[M] L[N]
L[N] - L[2] <= D
L[M] - L[1] <= D
L[N] - L[2] = (L[N] - L[M]) + (L[M] - L[1]) <= D
L[N] - L[M] <= D
Hence, L[M] and L[N] can be paired
Code
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
int main()
ll n,d,a;
vector<ll> v;
cin>>n>>d;
for(int i = 0;i<n;i++){
cin>>a;
v.push_back(a);
//Sort the list of sticks
sort(v.begin(),v.end());
int res = 0;
for(int i = 0;i<n-1;){
//If the adjacent difference is less than d
//we can make a pair
//Now remove these two sticks from the list
if(v[i+1] - v[i] <= d){
res++;
i+=2;
//If we cannot make a pair with adjacent stick
//This stick is useless, remove this stick from t
he list
else i++;
cout<<res<<endl;
return 0;
T = O(nlogn)
Ques. Expedetion
A damaged truck needs to travel a distance of L. The truck leaks one
unit of fuel for every unit distance it travels.There are N (<=10^4)fuel
stops on the path, what is the minimum number of refueling stops that
the truck needs to make given that it has P amout of fuel initially.
http://www.spoj.com/problems/EXPEDI/
The first observation is, if you want to reach the city, say, point L, you
have to ensure that every single point between the current
position and city must also be reachable.
Now, the task is to minimize the number of stoppages for fuel, which is
at most 10000. So, we sort the fuel stations, and start from current
position. For every fuel station, if we want to reach it, we must
have fuel f more than or equal to the distance d. Also, using the
larger capacities will always reduce the number of stations we must
stop.
How does greedy work?
If we make sure that we only stop at the largest capicity fuel stations
upto the point where the fuel capacity of truck becomes 0, number of
stops will be minimized.
Example:
Initial capacity = 11
Fuel Stations: 3 8 10 12
Capacity: 4 10 2 3
Initially, we don't have enough fuel to reach 12.
So we can reach upto maximum 11th city.
In order to minimize our stops, we will stop at 8th city
where fuel capacity is maximum.
Code:
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
bool cmpr(pair<int,int> l,pair<int,int> r){
return l.first > r.first;
}
int main(){
int n,t,x,d,f,D,F,prev = 0;
scanf("%d",&t);
while(t--){
int flag = 0,ans = 0;
vector<pair<int,int> > v;
priority_queue<int> pq;
scanf("%d",&n);
for(int i = 0;i<n;i++){
scanf("%d %d",&d,&f);
//Insert the city index and fuel capacity
v.push_back(make_pair(d,f));
//Sort the cities according to their location
sort(v.begin(),v.end(),cmpr);
scanf("%d %d",&D,&F);
//Calculate the difference between the current ci
ty and the
//destination i.e. v[i] = j means that we need to
travel j
//units to rach our destination
for(int i = 0;i<n;i++){
v[i].first = D - v[i].first;
//prev denotes the previous city visited
prev = 0;
//x will denote the current city that we are in
x = 0;
while(x < n){
//cout<<x<<" "<<F<<" "<<v[x].first<<" "<<prev
<<" "<<endl;
//If we have enough fuel to travel from prev
to current city
//Push this fuel station to priority_queue
//Reduce the amount of fuel used
//update the previous city
if(F >= (v[x].first - prev)){
F -= (v[x].first - prev);
pq.push(v[x].second);
prev = v[x].first;
//If we dont have enough fuel to visit
//the current city
//Find the max capacity fuel station between
//prev and current city and use it to refuel
else{
//If no fuel station is left
//i.e. we have used all of
//the fuel stations and still not abl
//to reach the city
//return FAIL!
if(pq.empty()){
flag = 1;
break;
//Increment the fuel capacity of truc
//by the maximum fuel station capacit
F += pq.top();
//Remove that fuel station from heap
pq.pop();
//Increment the number of used fuel
//station by 1
ans++;
continue;
//If we have visited the current city
//Visit next city
x++;
}
if(flag){
printf("-1\n");
continue;
//Find the distance between the destination
//and last city
//Check if it is possible to visit the destinatio
//from the last city.
D = D - v[n-1].first;
if(F >= D){
printf("%d\n",ans);
continue;
while(F < D){
if(pq.empty()){
flag = 1;
break;
F += pq.top();
pq.pop();
ans++;
if(flag){
printf("-1\n");
continue;
printf("%d\n",ans);
return 0;
T = O(NlogN)
Ques. Knapsack Problem
You are given N items, each item has two parameters: the weight and
the cost. Let’s denote M as the sum of the weights of all the items.
Your task is to determine the most expensive cost of the knapsack, for
every capacity 1, 2, …, M. The capacity C of a knapsack means that the
sum of weights of the chosen items can’t exceed C.
https://www.codechef.com/problems/KNPSK
The key observaiton here is that weight of each item is either 1 or
2.
Greedy Approach: Greedily pickup the most costliest item with
weight <= 2, which can be taken in the knapsack.
Case 1: W is even
Select the most expensive item with sum of weight = 2. This can be
done in two ways:
Take the most expensive item of weight 2
Or take at most two most expensive item of weight 1
Note that after picking up the most expensive item with sum of weight
<= 2, we will remove the item taken and will recursively select the
items to fill the most expensive elements.
Case 2: W is odd
We can simply select the most expensive item of weight 1. Now, we
dont consider this item again. Now we have to select the most
expensive weights from the remaining items. Since W-1 is even, we
can solve this problem similar to case 1.
Example:
1 7 1 100 2 70
2 44 1 56 2 44
1 56 1 33 2 1
2 1 1 18
1 18
1 33
2 70
Case 1: Even
W = 2: (1,100) + (1,56) = 156
W = 4: 156 + (2,70) = 226
W = 6: 226 + (1,33) + (1,18) = 277
W = 8: 277 + (2,44) = 321
W = 10: 321 + (2,1) = 322
Case 2: Odd
W = 1: (1,100) = 100
W = 3: 100 + (1,56) + (1,33) = 189
W = 5: 189 + (2,70) = 259
W = 7: 259 + (2,44) = 303
W = 9: 321 + (1,18) = 321
Code
#include<iostream>
#include<vector>
#include<algorithm>
#include<stdio.h>
using namespace std;
long long cost[200000+10];
int main(){
int n,w,c,m,W = 0;
//Separate one and two for even and odd casses
vector<int> one,two,One,Two;
scanf("%d",&n);
for(int i = 0;i<n;i++){
scanf("%d %d",&w,&c);
//Insert weight 1 items in one vector
if(w == 1)
one.push_back(c);
//Insert weight 2 items in two vector
else
two.push_back(c);
W += w;
//sort the two vectors
sort(one.begin(),one.end());
sort(two.begin(),two.end());
One = one;
Two = two;
long long sum = 0,cur = 0,res = 0;
//even case
for(int i = 2;i<=W;i+=2){
//res1 --> when we take atmost two 1 wight items
//res2 --> when we take single 2 weight item
long long res1 = 0, res2 = 0;
//calc res2
if(two.size() > 0){
res2 = two[two.size()-1];
//calculate res1
if(one.size() > 1){
res1 = one[one.size()-1] + one[one.size()-2];
else if(one.size() > 0){
res1 = one[one.size() - 1];
//if res2 > res1 remove the 2 weight item
if(res2 > res1){
two.pop_back();
res += res2;
//remove at most two 1 weight items
else{
if(one.size() > 1){
one.pop_back();
one.pop_back();
else
one.pop_back();
res += res1;
}
//update the max cost for weight i
cost[i] = res;
//odd case
//subtract 1 to make the weight sum even
res = 0;
//Find the most expensive 1 weight item
//and remove it from the list
if(One.size() > 0){
res = One[One.size()-1];
One.pop_back();
cost[1] = res;
//Similar to even case
for(int i = 3;i<=W;i+=2){
long long res1 = 0, res2 = 0;
if(Two.size() > 0){
res2 = Two[Two.size()-1];
if(One.size() > 1){
res1 = One[One.size()-1] + One[One.size()-2];
}
else if(One.size() > 0){
res1 = One[One.size()-1];
if(res2 > res1){
Two.pop_back();
res += res2;
else{
if(One.size() > 1){
One.pop_back();
One.pop_back();
else
One.pop_back();
res += res1;
cost[i] = res;
for (int i = 1; i <= W; i++) {
if (i > 1) printf(" ");
printf("%lld", cost[i]);
printf("\n");
return 0;
}
T = O(nlogn)
