def solve(items,weights,values,capacities,tlimit): # Create solver solver = pywrapknapsack_solver.KnapsackSolver(pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,'problem') # Initialize solver solver.Init(values, weights, capacities) # Set time limit if given if tlimit > 0: solver.set_time_limit(tlimit) # Solve problem computed_value= solver.Solve() # Collect solution data packed_items= [x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x)] packed_weights=[] for i in range(len(weights)): packed_weights.append(0) for i in packed_items: for j in range(len(weights)): packed_weights[j]+=weights[j][i] return computed_value,packed_items,packed_weights
def get_ortool_value(self): # Create the solver. data = self.get_ortool_model() solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') values = data['values'] weights = data['weights'] capacities = data['capacity'] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 print('Total value =', computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] print('Total weight:', total_weight) print('Packed items:', packed_items) print('Packed_weights:', packed_weights) return computed_value
def solve_multi_knapsack(profits, weights, capacities, verbose=True): """Wrapper function for solving a multi-dimensional knapsack problem. Uses Google's ORtools library. Args: profits: list of N integers, indicating the profits associated with each of N items. weights: multi-dimensional list (M * N) of integers, where M is the number of weight dimensions to consider and N is the number of items capacities: list of M integers, indicating the max capacity along each of M dimensions Returns: list of integer indices of the chosen items """ solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. # KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'MKP_Solve') KNAPSACK_MULTIDIMENSION_CBC_MIP_SOLVER, 'MKP_Solve') solver.Init(profits, weights, capacities) computed_profit = solver.Solve() if verbose: print(('optimal profit = ' + str(computed_profit))) idx_chosen_items = [] for i in range(len(profits)): if solver.BestSolutionContains(i): idx_chosen_items.append(i) return idx_chosen_items
def get_allocation_rule(self, bids, weight_limit): """ Selects highest bids using dynamic programming optimisation technique """ values = [] weights = [[]] capacities = [weight_limit] for bid in bids: values.append(bid.value) # appends to the inner list weights[0].append(bid.weight) # https://developers.google.com/optimization/bin/knapsack # https://developers.google.com/optimization/reference/python/algorithms/pywrapknapsack_solver solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, 'KnapsackBids') solver.Init(values, weights, capacities) computed_value = solver.Solve() # # returns list of optimally packed indices selected_indices = [ x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x) ] # the indices are converted into their corresponding bids then returned return [bids[i] for i in selected_indices]
def main(): # Create the solver. solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') values = [ 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312 ] weights = [[ 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13 ]] capacities = [850] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 print('Total value =', computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] print('Total weight:', total_weight) print('Packed items:', packed_items) print('Packed_weights:', packed_weights)
def Knapsackpackingsolution_single(): data = {} data['Value'] = [ 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312 ] #a sequence data['Volumn'] = [[ 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13 ]] data['limitation'] = [850] solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'kNAPSACK') solver.Init(data['Value'], data['Volumn'], data['limitation']) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 print('Total value =', computed_value) for i in range(len(data['Value'])): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(data['Volumn'][0][i]) total_weight += data['Volumn'][0][i] print('Total weight:', total_weight) print('Packed items:', packed_items) print('Packed_weights:', packed_weights)
def recommand(): # Create the solver. solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_SCIP_MIP_SOLVER, 'KnapsackExample') valid_players = DataPipeline().valid_players values = valid_players['SCR'].tolist() weights = [valid_players['RATING'].tolist()] capacities = [430] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 # print('Total value =', computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] print('Total weight:', total_weight) print('Total_Scores:', valid_players.iloc[packed_items]['SCR'].sum()) print(valid_players.iloc[packed_items])
def ortoolopt(weights, values, cap): weights = [list(weights)] values = list(values) solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, "KnapsackExample", ) solver.Init(values, weights, [cap]) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 # print("Total value =", computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] # print("Total weight:", total_weight) # print("Packed items:", packed_items) # print("Packed_weights:", packed_weights) selection = np.zeros(len(values)) selection[packed_items] = 1 return ( selection.astype(int), total_weight, len(values), cap - total_weight, )
def main(): # Create the solver. # [START solver] solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, "test") # [END solver] # [START data] weights = [[ 565, 406, 194, 130, 435, 367, 230, 315, 393, 125, 670, 892, 600, 293, 712, 147, 421, 255 ]] capacities = [850] values = weights[0] # [END data] # [START solve] solver.Init(values, weights, capacities) computed_value = solver.Solve() # [END solve] # [START print_solution] packed_items = [ x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x) ] packed_weights = [weights[0][i] for i in packed_items] print("Packed items: ", packed_items) print("Packed weights: ", packed_weights) print("Total weight (same as total value): ", computed_value)
def exo1(): # Create the solver. solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') values = [40, 30, 25, 25, 10] weights = [[10, 4, 3, 2, 1]] capacities = [15] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 print('Total value =', computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] print('Total weight:', total_weight) print('Packed items:', packed_items) print('Packed_weights:', packed_weights)
def main(): # Create the solver. solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') weights = [[100, 26, 9, 11, 51, 231, 24, 79, 161]] values = [12, 10, 3, 4, 14, 45, 9, 4, 20] capacities = [500] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 print('Total value =', computed_value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] print('Total weight:', total_weight) print('Packed items:', packed_items) print('Packed_weights:', packed_weights)
def solve_it_google(items,capacity): values = [item.value for item in items] print(values) weights = [[item.weight for item in items]] print(weights) #capacity solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver. KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') solver.Init(values, weights, [capacity]) value = solver.Solve() taken_items = [] packed_weights = [] total_weight = 0 taken = [0] * len(items) print('Total value =', value) for i in range(len(values)): if solver.BestSolutionContains(i): taken_items.append(i) packed_weights.append(weights[0][i]) total_weight += weights[0][i] for ind in taken_items: taken[items[ind].index] = 1 output_data = str(int(value)) + ' ' + str(0) + '\n' output_data += ' '.join(map(str, taken)) return output_data
def main(): # Create the solver. # [START solver] solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') # [END solver] # [START data] values = [ 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312 ] weights = [[ 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13 ]] capacities = [850] # [END data] # [START solve] solver.Init(values, weights, capacities) computed_profit = solver.Solve() # [END solve] # [START print_solution] print('optimal profit =', computed_profit)
def main(): # Create the solver. solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'test') values = [ 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312 ] weights = [[ 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13 ]] capacities = [850] solver.Init(values, weights, capacities) computed_value = solver.Solve() packed_items = [ x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x) ] packed_weights = [weights[0][i] for i in packed_items] total_weight = sum(packed_weights) print("Packed items: ", packed_items) print("Packed weights: ", packed_weights) print("Total value: ", computed_value) print("Total weight: ", total_weight)
def run_algorithm(self): from ortools.algorithms import pywrapknapsack_solver solver = pywrapknapsack_solver.KnapsackSolver(\ pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,\ 'solver') # Scaling Items epsilon = 0.3 print("Scaling items for {0}-epsilon approximation".format(epsilon)) # Randomly select a group of non-conflict items to do knapsack on: print("Randomly select a group of items that have no conflicts") items = self.compatible_items_random(self.N) # Preprocess Data print("Preprocess Data") weights = list() values = list() capacities = list() map_indicies_to_item = dict() item_costs = list() item_weights = list() max_profit = max([x.profit for x in self.items]) scaling_factor = self.N / epsilon / max_profit print("Scaling factor: {0}".format(scaling_factor)) for i, item in enumerate(items): values.append(min(item.profit * scaling_factor, 0)) item_weights.append(item.weight) item_costs.append(item.cost) map_indicies_to_item[i] = item # Form Knapsack problem print("Creating Knapsack problem") weights.append(item_costs) capacities.append(self.M) weights.append(item_weights) capacities.append(self.P) # Initialize Solver solver.Init(values, weights, capacities) # Solve print("Solving...") picked = solver.Solve() print("Done!") # Retrieve solution print("Converting solution to items...") packed_items_indices = [x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x)] packed_items = [map_indicies_to_item[x] for x in packed_items_indices] print("Success!") return packed_items
def knapsack_multidimensional_cbc(request, test_mode=False, muestreo=0, repeticiones=1): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_CBC_MIP_SOLVER, "Multi-dimensional solver") return knapsack_multidimensional(request, solver, test_mode, muestreo, repeticiones)
def solve_knapsack(method, objects_id, weights, every_trailer_axis, objects_price): flat_list = [] # список весов for j in range(1): flat_list.append([]) for i in range(len(weights)): flat_list[j].append(weights[i]) # Заполнение списка весов capacities = [every_trailer_axis] # Максимальная вместимость if method == "Weight": # Если оптимизация по весу leng = len(flat_list[0]) values = [] for i in range(leng): values.append( 0) # ценность не учитывается. У всех объектов одинаковая # Иннициализация алгоритма решения для загрузки максимальным весом solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, 'test') solver.Init(values, flat_list, capacities) computed_value = solver.Solve() packed_items = [ x for x in range(0, len(flat_list[0])) if solver.BestSolutionContains(x) ] packed_items_ids = [] for i in packed_items: # Получение id упакованных вещей packed_items_ids.append(objects_id[i]) elif method == "Value": # Если оптимизация по ценности # Инициализация алгоритма решения для загрузки максимально ценными вещами solver_2 = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'test') capacities = [every_trailer_axis] solver_2.Init(objects_price, flat_list, capacities) packed_items = [ x for x in range(0, len(flat_list[0])) if solver_2.BestSolutionContains(x) ] packed_items_ids = [] # Идентификаторы получаемых вещей for i in packed_items: # Получение id упакованных вещей packed_items_ids.append(objects_id[i]) return packed_items_ids
def knapsack_solver(self, capacity, values, weights): solver = pywrapknapsack_solver.KnapsackSolver(pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,'test') solver.Init(values, weights, capacity) computed_value = solver.Solve() packed_items = [x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x)] packed_weights = [weights[0][i] for i in packed_items] total_weight = sum(packed_weights) return packed_items, packed_weights, computed_value, total_weight
def init_model(self, **kwargs): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') list_item = self.knapsack_model.list_items max_capacity = self.knapsack_model.max_capacity values = [item.value for item in list_item] weights = [[item.weight for item in list_item]] capacities = [max_capacity] solver.Init(values, weights, capacities) self.model = solver
def knapsolve(values,weights,budget): assert values.dtype==weights.dtype==int values = list(values) weights = [list(weights)] solver = pywrapknapsack_solver.KnapsackSolver(pywrapknapsack_solver.KnapsackSolver.KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER,'globalpfrl') solver.Init(values,weights,[budget]) total_importances = solver.Solve() best_items = [x for x in range(len(weights[0])) if solver.BestSolutionContains(x)] best_values = [weights[0][i] for i in best_items] return best_items
def knapsack(capacity, sizes, values): sizes = [sizes] solver = pywrapknapsack_solver.KnapsackSolver(pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'KnapsackExample') solver.Init(values, sizes, [capacity]) computed_value = solver.Solve() items = [] for i in range(len(values)): if solver.BestSolutionContains(i): items.append(i) return computed_value, items
def knapsack(items: List[Item], capacity: float) -> Tuple[float, List[int]]: """ Knapsack Solver using OR-Tools https://developers.google.com/optimization/bin/knapsack#complete-programs Addition Details can be found here: https://google.github.io/or-tools/ http://google.github.io/or-tools/python/ortools/algorithms/pywrapknapsack_solver.html """ values = [] weights = [] capacities = [] for item in items: values.append(item.value) temp_weights = [] for item in items: temp_weights.append(item.weight) weights.append(temp_weights) capacities = [capacity] # print(f"Values: {values}") # print(f"Weights: {weights}") # http://google.github.io/or-tools/python/ortools/algorithms/pywrapknapsack_solver.html # Dynamic Programming Solver is also available through `KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER` solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'Knapsack') # You can also set a time limit here to make sure that the solution is terminated if it takes too long # Use `set_time_limit()` method for this solver.Init(values, weights, capacities) computed_value = solver.Solve() taken: List[int] = [] for i in range(len(values)): if solver.BestSolutionContains(i): taken.append(1) else: taken.append(0) # print('Taken:', taken) # print('Total weight:', computed_value) return computed_value, taken
def solve_it(input_data): from ortools.algorithms import pywrapknapsack_solver # parse the input lines = input_data.split('\n') firstLine = lines[0].split() item_count = int(firstLine[0]) capacity = int(firstLine[1]) values = [] weights = [] capacities = [capacity] for i in range(1, item_count + 1): line = lines[i] parts = line.split() _value = int(parts[0]) _weight = int(parts[1]) values.append(_value) weights.append(_weight) weights = [weights] # Instanciate the solver str_solver = 'NItems_{}_Capacity_{}'.format(item_count, capacity) solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, str_solver) solver.Init(values, weights, capacities) value = solver.Solve() packed_items = [] packed_weights = [] actual_cap = 0 print('Total value =', value) for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) packed_weights.append(weights[0][i]) actual_cap += weights[0][i] # prepare the solution in the specified output format output_data = "Obj-value: {}, total weight: {} ({})\n".format( value, actual_cap, actual_cap / capacity) #output_data = str(value) + ' ' + str(0) + '\n' output_data += ' '.join(map(str, packed_items)) return output_data
def solve_by_ortools(item_count, capacity, items): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, 'Solver') profits = [] weights = [] for item in items: profits.append(item.value) weights.append(item.weight) solver.set_time_limit(10) solver.Init(profits, [weights], [capacity]) profit = solver.Solve() result_str = '{} 0\n'.format(profit) result_str += ' '.join( [str(int(solver.BestSolutionContains(i))) for i in range(item_count)]) return result_str
def _solveKnapsack(values, weights, capacity): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, '') capacities = [capacity] solver.Init(values, [weights], capacities) computed_value = solver.Solve() packed_items = [] packed_weights = [] total_weight = 0 for i in range(len(values)): if solver.BestSolutionContains(i): packed_items.append(i) return packed_items
def solve_it(input_data): # Modify this code to run your optimization algorithm # parse the input lines = input_data.split('\n') firstLine = lines[0].split() item_count = int(firstLine[0]) capacity = int(firstLine[1]) solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, 'test') values = [] weights = [] for line_idx in range(1, item_count + 1): line = lines[line_idx] parts = line.split() #val we values.append(int(parts[0])) weights.append(int(parts[1])) weights = [weights] solver.Init(values, weights, [capacity]) solver.Solve() packed_items = [ x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x) ] bool_items = [] for i in range(item_count): if i in packed_items: bool_items.append(1) else: bool_items.append(0) packed_weights = [weights[0][i] for i in packed_items] # prepare the solution in the specified output format output_data = str(sum(packed_weights)) + ' ' + str(1) + '\n' output_data += ' '.join(map(str, bool_items)) return output_data
def dySolve(knapsack, maxWeight): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, 'test') values = [] weights = [[]] capacities = [maxWeight] for item in knapsack.items: values.append(item.value) weights[0].append(item.weight) solver.Init(values, weights, capacities) computed_value = solver.Solve() return computed_value
def knapsack_ortools(values, weights, items, capacity): """0-1 Knapsack problem solver""" osolver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver.KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, "SummarizationSegmentSelection") scale = 1000 values = np.array(values) weights = np.array(weights) values = (values * scale).astype(np.int) weights = (weights).astype(np.int) capacity = capacity osolver.Init(values.tolist(), [weights.tolist()], [capacity]) osolver.Solve() packed_items = [x for x in range(0, len(weights)) if osolver.BestSolutionContains(x)] return packed_items
def post(self): data = request.get_json() profits = data['profits'] weights = data['weights'] capacities = data['capacities'] solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER, "bpp_solver") solver.Init(profits, weights, capacities) computed_value = solver.Solve() packed_items = [x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x)] packed_weights = [weights[0][i] for i in packed_items] total_weight = sum(packed_weights) return jsonify({ 'packed_items': packed_items, 'total_profit': computed_value, 'total_weight': total_weight })
def main(): solver = pywrapknapsack_solver.KnapsackSolver( pywrapknapsack_solver.KnapsackSolver. KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, 'test') values = [16, 19, 23, 28] weights = [[2, 3, 4, 5]] capacity = [7] solver.Init(values, weights, capacity) computed_value = solver.Solve() packed_items = [ x for x in range(0, len(weights[0])) if solver.BestSolutionContains(x) ] packed_weights = [weights[0][i] for i in packed_items] print("持ち出しアイテム:", packed_items) print("持ち出すアイテムの重さ: ", packed_weights) print("持ち出しアイテムの合計の価値:", computed_value)