discrete_optimization/knapsack/knapsack.py

167 lines
5.7 KiB
Python

from collections import namedtuple
Result = namedtuple("Result", ['objective', 'is_optimal', 'xs'])
Item = namedtuple("Item", ['index', 'value', 'weight'])
Knapsack = namedtuple("Knapsack", ['count', 'capacity', 'items'])
Node = namedtuple("Node", ['index', 'value', 'room', 'estimate', 'path'])
def solve_knapsack_greedy(knapsack):
remaining_capacity = knapsack.capacity
current_value = 0
xs = [0] * knapsack.count
for item in knapsack.items:
if remaining_capacity >= item.weight:
remaining_capacity -= item.weight
current_value += item.value
xs[item.index] = 1
return Result(current_value, 0, xs)
def solve_knapsack_dynamic(knapsack):
value_column = [0 for _ in range(knapsack.capacity + 1)]
# Keep track for each item for what capacities we take
# the respective item. This allows us to backtrack the items
# for the optimal solution later.
item_taken = {i: set() for i in range(len(knapsack.items))}
for item in knapsack.items:
new_column = list(value_column)
for capacity in range(knapsack.capacity + 1):
if item.weight <= capacity:
# Calculate the new value for the capacity if we take the item.
new_value = item.value + value_column[capacity - item.weight]
if new_value > value_column[capacity]:
new_column[capacity] = new_value
item_taken[item.index].add(capacity)
# There is no else case because new_colum contains the right values
# from the previous item so we only have to update when the new
# value is better.
value_column = new_column
objective = value_column[-1]
# Dynamic programing computes the best posible solution.
is_optimal = 1
# Reconstruct which items are used for the optimal solution.
xs = []
current_index = knapsack.items[-1].index
current_capacity = knapsack.capacity
while current_index >= 0:
if current_capacity in item_taken[current_index]:
current_capacity -= knapsack.items[current_index].weight
xs.append(1)
else:
xs.append(0)
current_index -= 1
xs.reverse()
return Result(objective, is_optimal, xs)
def solve_knapsack_depth_first_search(knapsack):
knapsack.items.sort(key=lambda item: item.value / float(item.weight),
reverse=True)
def get_estimate(current_value, current_index, remaining_capacity):
estimated_value = current_value
for item in knapsack.items[current_index:]:
if item.weight <= remaining_capacity:
estimated_value += item.value
remaining_capacity -= item.weight
else:
v = int((remaining_capacity / float(item.weight)) * item.value)
estimated_value += v
return estimated_value
return estimated_value
estimate = get_estimate(0, 0, knapsack.capacity)
nodes = [Node(0, 0, knapsack.capacity, estimate, [])]
num_items = len(knapsack.items)
best_value = 0
best_path = []
while nodes:
current_node = nodes.pop()
current_index = current_node.index
if current_node.room < 0:
continue
if current_node.estimate < best_value:
continue
if current_node.value > best_value:
best_value = current_node.value
best_path = list(current_node.path)
if current_index == num_items:
continue
current_item = knapsack.items[current_index]
# Right child - do not take current_item
new_index = current_index + 1
new_value = current_node.value
new_room = current_node.room
new_estimate = get_estimate(new_value, new_index, new_room)
if new_estimate > best_value:
new_path = current_node.path + [0]
r = Node(new_index, new_value, new_room, new_estimate, new_path)
nodes.append(r)
# Left child - take current_item
new_index = current_index + 1
new_room = current_node.room - current_item.weight
if new_room >= 0:
new_value = current_node.value + current_item.value
new_estimate = get_estimate(new_value, new_index, new_room)
new_path = current_node.path + [1]
n = Node(new_index, new_value, new_room, new_estimate, new_path)
nodes.append(n)
# If we sort the items by estimate here it becomes
# best first search.
# nodes.sort(key=lambda node: node.estimate)
def correct_path(path):
path = path + [0] * (num_items - len(path))
values = zip(path, knapsack.items)
path = [v[0] for v in sorted(values, key=lambda value: value[1].index)]
return path
return Result(best_value, 0, correct_path(best_path))
def input_data_to_knapsack(input_data):
lines = input_data.split('\n')
item_count, capacity = map(int, lines[0].split())
items = []
for i in range(1, item_count + 1):
line = lines[i]
value, weight = map(int, line.split())
items.append(Item(i - 1, value, weight))
k = Knapsack(item_count, capacity, items)
return k
def result_to_output_data(result):
# prepare the solution in the specified output format
output_data = str(result.objective) + ' ' + str(result.is_optimal) + '\n'
output_data += ' '.join(map(str, result.xs))
return output_data
if __name__ == '__main__':
file_location = "./data/ks_60_0"
with open(file_location, 'r') as input_data_file:
input_data = input_data_file.read()
k = input_data_to_knapsack(input_data)
print(result_to_output_data(solve_knapsack_dynamic(k)))
print(result_to_output_data(solve_knapsack_depth_first_search(k)))