add heap

Author: Aman Kumar

.DS_Store

@@ -0,0 +1,37 @@
+# @param {Integer[]} start_time
+# @param {Integer[]} end_time
+# @param {Integer[]} profit
+# @return {Integer}
+Job = Struct.new(:start, :end, :profit, :pos)
+def job_scheduling(start_time, end_time, profit)
+    return if start_time.length.zero?
+    return profit[0] if start_time.length == 1
+
+    jobs = []
+    for i in (0...start_time.length)
+        jobs << Job.new(start_time[i], end_time[i], profit[i], i+1)
+    end
+    jobs.sort_by!(&:profit).reverse!
+    schedule = Array.new(end_time.max)
+
+    profit = 0
+
+    for i in (0...jobs.length)
+        available = true
+        current_job = jobs[i]
+        for j in (jobs[i].start...jobs[i].end)
+             if schedule[j]
+                 available = false
+                 break
+             end
+        end
+        next unless available
+        for j in (jobs[i].start...jobs[i].end)
+             schedule[j] = true
+        end
+
+        profit += jobs[i].profit
+
+    end
+    profit
+end

dp/job_scheduling_max_profit.rb

@@ -0,0 +1,49 @@
+# 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.
+
+class Item
+  attr_reader :weight, :value, :pos
+
+  def initialize(wt, val, pos)
+    @weight = wt
+    @value = val
+    @pos = pos
+  end
+
+  def val_to_wt
+    @value / @weight
+  end
+
+  def to_s
+    "wt: #{@weight}, val: #{@value}, val_to_wt: #{val_to_wt} pos: #{@pos}"
+  end
+end
+
+def get_max(wt, val, capacity)
+  items = []
+  (0...wt.length).each do |i|
+    items << Item.new(wt[i], val[i], i + 1)
+  end
+  # sort as per decreasing order of val_to_wt
+  items.sort! { |a, b| b.val_to_wt <=> a.val_to_wt }
+  curr_capacity = 0
+  total_value = 0
+  items.each do |item|
+    if item.weight <= capacity - curr_capacity
+      curr_capacity += item.weight
+      total_value += item.value
+    else
+      # include fractional weight
+      fraction = (capacity - curr_capacity) / item.weight.to_f
+      total_value += (fraction * item.value).to_i
+      curr_capacity += (fraction * item.weight)
+      break
+    end
+  end
+  total_value
+end
+
+wt = [10, 40, 20, 30]
+val = [60, 40, 100, 120]
+capacity = 50
+
+puts get_max(wt, val, capacity)

greedy/fractional_knapsack.rb

@@ -0,0 +1,73 @@
+# Given an array of jobs where every job has a deadline and associated profit if the job is finished before the deadline.
+# It is also given that every job takes a single unit of time, so the minimum possible deadline for any job is 1.
+# How to maximize total profit if only one job can be scheduled at a time.
+# Input: Four Jobs with following
+# deadlines and profits
+# JobID  Deadline  Profit
+#   a      4        20
+#   b      1        10
+#   c      1        40
+#   d      1        30
+# Output: Following is maximum
+# profit sequence of jobs
+#         c, a
+
+# function to schedule the jobs take 2
+# arguments array and no of jobs to schedule
+def job_sequencing(arr, max_deadline)
+  return if arr.empty?
+
+  length = arr.length
+
+  # sort array by decending profit
+  arr.sort! { |a, b| b[2] <=> a[2] }.to_s
+
+  # true denotes time_slot is empty
+  time_slots = Array.new(max_deadline) { |_a| true }
+  output = []
+  profit = 0
+  filled_slots = 0
+  arr.each_with_index do |job, _index|
+    min_deadline = [max_deadline, job[1]].min
+
+    # as index start from 0, and min deadline can be 1. We decremented 1
+    min_deadline -= 1
+
+    # try to accomodate job at deadline or before
+    while min_deadline >= 0
+      # empty slot found
+      if time_slots[min_deadline]
+        time_slots[min_deadline] = false
+        profit += job[2]
+        output[min_deadline] = job[0]
+        filled_slots += 1
+        break
+      end
+      min_deadline -= 1
+    end
+    break if filled_slots == max_deadline
+  end
+  output
+end
+
+# Driver COde
+# # Job Array
+# With job name, deadline, profit
+arr = [['a', 2, 100],
+       ['b', 1, 19],
+       ['c', 2, 27],
+       ['d', 1, 25],
+       ['e', 3, 15]]
+
+print('Following is maximum profit sequence of jobs')
+
+# Function Call
+puts job_sequencing(arr, 3).to_s
+
+arr = [['j1', 2, 60],
+       ['j2', 1, 100],
+       ['j3', 3,  20],
+       ['j4', 2,  40],
+       ['j5', 1,  20]]
+
+puts job_sequencing(arr, 3).to_s

linklist/delete greedy/huffman_coding.rb

@@ -0,0 +1,43 @@
+# There is one meeting room in a firm.
+# There are N meetings in the form of (S[i], F[i])
+# where S[i] is the start time of meeting i and F[i] is finish time of meeting i.
+# The task is to find the maximum number of meetings that can be accommodated in the meeting room.
+# Print all meeting numbers
+
+# class Meeting
+#   attr_accessor :start, :ending, :pos
+#   def initialize(start, ending, pos)
+#     @start = start
+#     @end = ending
+#     @pos = pos
+#   end
+# end
+#
+Meeting = Struct.new(:start, :end, :pos)
+
+def max_meeting(start, finish)
+  length = start.length
+  meetings = []
+  (0...length).each do |i|
+    meetings << Meeting.new(start[i], finish[i], i + 1)
+  end
+
+  meetings.sort_by!(&:end)
+
+  output = []
+  output << meetings.shift
+  meetings.each do |meeting|
+    output << meeting if output.last.end <= meeting.start
+  end
+  output.map { |e| e.pos }
+end
+# Starting time
+s = [1, 3, 0, 5, 8, 5]
+
+# Finish time
+f = [2, 4, 6, 7, 9, 9]
+
+puts max_meeting(s, f).to_s
+
+# max_meeting([75250, 50074, 43659, 8931, 11273, 27545, 50879, 77924],
+#   [112960, 114515, 81825, 93424, 54316, 35533, 73383, 160252])

greedy/job_sequencing_max_profit.rb

@@ -0,0 +1,35 @@
+# Given a value V, if we want to make a change for V Rs, and we have an infinite supply of each of the denominations in Indian currency,
+# i.e., we have an infinite supply of { 1, 2, 5, 10, 20, 50, 100, 500, 1000} valued coins/notes,
+# what is the minimum number of coins and/or notes needed to make the change?
+
+# Input: V = 70
+# Output: 2
+# We need a 50 Rs note and a 20 Rs note.
+#
+# Input: V = 121
+# Output: 3
+# We need a 100 Rs note, a 20 Rs note and a 1 Rs coin.
+
+def coin_change(coins, amount)
+  return 0 if amount.zero?
+
+  output = 0
+  remaining = amount
+  coins.sort! { |a, b| b <=> a }
+  coins.each do |coin|
+    num = remaining / coin
+    next if num.zero?
+
+    remaining -= (coin * num)
+    output += num
+    return output if remaining.zero?
+  end
+  -1
+end
+
+# coins = [1, 2, 5]
+deno = [1, 2, 5, 10, 20, 50,
+        100, 500, 1000]
+amount = 11
+
+puts coin_change(deno, amount)

greedy/max_meetings_in_a_room.rb

@@ -0,0 +1,53 @@
+# build max heap from array
+
+def heapify_max(arr, index)
+  return arr if arr.empty?
+
+  largest = index
+  left = (index * 2) + 1
+  right = (index * 2) + 2
+
+  # check if left exist, and value of left is greater then root
+  largest = left if left < arr.length && arr[left] > arr[largest]
+  largest = right if right < arr.length && arr[right] > arr[largest]
+
+  # swap if largest is not root index
+  if largest != index
+    arr[largest], arr[index] = arr[index], arr[largest]
+
+    # Recursively heapify the affected sub-tree
+    heapify_max(arr, largest)
+  end
+end
+
+def heapify_min(arr, index)
+  smallest = index
+  left = 2 * index + 1
+  right = 2 * index + 2
+  length = arr.length
+
+  smallest = left if left < length && arr[left] < arr[smallest]
+  smallest = right if right < length && arr[right] < arr[smallest]
+
+  if smallest != index
+    arr[smallest], arr[index] = arr[index], arr[smallest]
+    heapify_min(arr, smallest)
+  end
+end
+
+def build_heap(arr)
+  return arr if arr.empty?
+
+  # Find 1st non leaf
+  length = arr.length
+  start_index = length / 2 - 1
+  start_index.downto(0).each do |i|
+    heapify_max(arr, i)
+  end
+end
+
+arr = [1, 3, 5, 4, 6, 13,
+       10, 9, 8, 15, 17]
+build_heap(arr)
+
+puts arr.to_s