Greedy Algorithm examples

Author: jai2dev

Python/Algorithms/Common Greedy Problems/activity_selection.py

@@ -0,0 +1,50 @@
+import sys
+
+"""Prints a maximum set of activities that can be done by a 
+single person, one at a time"""
+# n --> Total number of activities 
+# start--> An array that contains start time of all activities 
+# finish --> An array that contains finish time of all activities 
+
+#utility function
+def compare(a):
+return a[1] #creturn finish time of that activity
+
+
+
+def printMaxActivities(arr,n): 
+
+s_arr=sorted(arr,key=compare) #sorting the array on the basis of finish time, using the key function we have just created above
+
+
+print("The following activities are selected")
+
+# The first activity is always selected 
+i = 0
+print(s_arr[i])
+
+# Consider rest of the activities 
+for j in range(n): 
+
+# If this activity has start time greater than 
+# or equal to the finish time of previously 
+# selected activity, then select it 
+if s_arr[j][0] >= s_arr[i][1]: 
+print(s_arr[j]) 
+i = j 
+
+# Driver code
+if __name__ == '__main__':
+print('enter the number of activities')
+n=int(input())
+
+print('enter the start time and end time of activities')
+print('start time___end time')
+arr=[]
+for i in range(n):
+arr.append(list(map(int,input().split()))) #example list [[1,3],[2,4],[4,6]]
+
+printMaxActivities(arr,n)
+
+
+

Python/Algorithms/Common Greedy Problems/egyptian_fraction.py

@@ -0,0 +1,51 @@
+import sys 
+import math 
+
+
+
+# define a function egyptianFraction 
+# which receive parameter nr as 
+# numerator and dr as denominator 
+def egyptianFraction(nr, dr): 
+
+print("\nThe Egyptian Fraction " +
+"Representation of {0}/{1} is". 
+format(nr, dr), end=" ") 
+
+# empty list ef to store 
+# denominator 
+ef = [] 
+
+# while loop runs until 
+# fraction becomes 0 i.e, 
+# numerator becomes 0 
+while nr != 0: 
+
+# taking ceiling 
+x = math.ceil(dr / nr) 
+
+# storing value in ef list 
+ef.append(x) 
+
+# updating new nr and dr 
+nr = x * nr - dr 
+dr = dr * x 
+
+# printing the values 
+for i in range(len(ef)): 
+if i != len(ef) - 1: 
+print(" 1/{0} +" . 
+format(ef[i]), end = " ") 
+else: 
+print(" 1/{0}" . 
+format(ef[i]), end = " ") 
+
+if __name__ == '__main__':
+print('enter the fraction you want to find egyptian fraction of')
+
+nr,dr=input().split('/') #enter the number in fraction form and then take the numerator and denominator part
+nr,dr=int(nr),int(dr)
+
+egyptianFraction(nr,dr)
+
+

Python/Algorithms/Common Greedy Problems/fractional_knapsack.py

@@ -0,0 +1,40 @@
+import sys
+import os
+
+# print the optimal value 
+
+def get_optimal_value(capacity,weights, v_w):
+ value = 0.
+ weight=0
+
+ while weight<capacity:
+
+
+ temp=max(v_w)
+
+ p=v_w.index(temp) 
+ q=v_w.pop(p)
+ r=weights.pop(p)
+
+ if r<=capacity:
+ value +=(r*q)
+ weight+=r
+ else:
+ value+=(capacity-weight)*q
+ weight+=capacity-weight
+
+
+ return value
+
+
+
+if __name__ == "__main__":
+ print('enter the input in format [n, capacity, value1, weight1, value2, weight2.....]')
+ data = list(map(int, input().split())) #example input format [n, capacity, value1, weight1, value2, weight2.....]
+ n, capacity = data[0:2]
+ values = data[2:(2 * n + 2):2]#extracting values from data
+ weights = data[3:(2 * n + 2):2] #extracting weights from data
+ v_w= [ i/j for i,j in zip(values,weights)] #storing them in value1/weight1 format
+ opt_value = get_optimal_value(capacity, weights, v_w)
+ print("max value one can take {:.4f}".format(opt_value))
+ 

Python/Algorithms/Common Greedy Problems/police_thief.py

@@ -0,0 +1,53 @@
+import sys
+
+# Python3 program to find maximum 
+# number of thieves caught 
+
+# Returns maximum number of thieves 
+# that can be caught. 
+def policeThief(arr, n, k): 
+i = 0
+l = 0
+r = 0
+res = 0
+thi = [] 
+pol = [] 
+
+# store indices in list 
+while i < n: 
+if arr[i] == 'P': 
+pol.append(i) 
+elif arr[i] == 'T': 
+thi.append(i) 
+i += 1
+
+# track lowest current indices of 
+# thief: thi[l], police: pol[r] 
+while l < len(thi) and r < len(pol): 
+
+# can be caught 
+if (abs( thi[l] - pol[r] ) <= k): 
+res += 1
+l += 1
+r += 1
+
+# increment the minimum index 
+elif thi[l] < pol[r]: 
+l += 1
+else: 
+r += 1
+
+return res 
+
+# Driver program 
+if __name__=='__main__': 
+
+print('enter the array containing position of policeman and thief exa:["P","T","P"....]')
+arr=list(input().split())
+print('enter the max distance unit police can catch thief')
+k = int(input())
+n = len(arr) 
+print(("Maximum thieves caught: {}". 
+format(policeThief(arr, n, k)))) 
+
+

Python/Algorithms/Common Greedy Problems/problem_specifications.txt

@@ -0,0 +1,60 @@
+Problem : Fractional Knapsack
+
+ Information:
+	Given weights and values of n items, we need to put these items in a knapsack of capacity W to get the maximum total value in the knapsack.
+	Example:
+	Items as (value, weight) pairs
+	arr[] = {{60, 10}, {100, 20}, {120, 30}}
+	Knapsack Capacity, W = 50;
+	Output:
+	Maximum possible value = 240
+	by taking items of weight 10 and 20 kg and 2/3 fraction
+	of 30 kg. Hence total price will be 60+100+(2/3)(120) = 240
+
+Problem : Policeman_Thief
+
+ Information :
+ Given an array of size n that has the following specifications:
+
+ Each element in the array contains either a policeman or a thief.
+ Each policeman can catch only one thief.
+ A policeman cannot catch a thief who is more than K units away from the policeman.
+
+ We need to find the maximum number of thieves that can be caught.
+
+ Examples:
+
+ Input : arr[] = {'P', 'T', 'T', 'P', 'T'},
+ k = 1.
+ Output : 2.
+ Here maximum 2 thieves can be caught, first
+ policeman catches first thief and second police-
+ man can catch either second or third thief.
+'
+
+
+Problem : Activity Selection problem
+
+Information:
+You are given n activities with their start and finish times. Select the maximum number of activities that can be performed by a single person, assuming that a person can only work on a single activity at a time.
+
+Example : 
+Consider the following 3 activities sorted by
+by finish time.
+ start[] = {10, 12, 20};
+ finish[] = {20, 25, 30};
+A person can perform at most two activities. The 
+maximum set of activities that can be executed 
+is {0, 2} [ These are indexes in start[] and 
+finish[] ]
+
+
+
+Problem : Egyptian Fraction
+
+Information:
+Every positive fraction can be represented as sum of unique unit fractions. A fraction is unit fraction if numerator is 1 and denominator is a positive integer, for example 1/3 is a unit fraction. Such a representation is called Egyptian Fraction as it was used by ancient Egyptians.
+
+Example:
+
+Egyptian Fraction Representation of 2/3 is 1/2 + 1/6