Решение рюкзака 0/1 с использованием динамического программирования в Python

В этой статье мы решим проблему knaxack 0/1, используя динамическое программирование.

Динамическое программирование Это алгоритмическая техника для решения проблемы оптимизации, нарушая ее в более простые подбпроблемы и используя тот факт, что оптимальное решение общей проблемы зависит от оптимального решения его субпроблемы Отказ

0/1 рюкзак Возможно, самая популярная проблема при динамическом программировании. Это также большая проблема для изучения, чтобы получить динамическое программирование.

В этом уроке мы узнаем о том, что именно 0/1 Knaxackack и как мы можем решить его в Python, используя динамическое программирование.

Давайте начнем.

Заявление о проблеме на 0/1 рюкзак

Задача отчетности динамического программирования заключается в следующем:

Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack.

Для начала у нас есть весовой массив, который имеет вес всех предметов. У нас также есть ценный массив, который имеет значение всех элементов, и у нас есть общая емкость веса рюкзака.

Учитывая эту информацию, нам нужно найти максимальное значение, которое мы можем получить во время превышения веса.

Проблема называется 0/1 рюкзак, потому что мы можем либо включите элемент в целом или исключить его. То есть Мы не можем принять долю предмета.

Давайте возьмем пример, чтобы понять.

Возьмите следующие входные значения.

val = [50,100,150,200]
wt = [8,16,32,40]
W = 64

Здесь мы получаем максимальную прибыль, когда мы включаем предметы 1,2 и 4 давая нам в общей сложности 200 + 50+.

Поэтому общая прибыль выходит как:

Как решить 0/1 Knaxackack с помощью динамического программирования?

Чтобы решить 0/1 Knaxackack, используя динамическое программирование, мы строим таблицу со следующими размерами.

[n + 1][W + 1]

Ряды стола соответствуют предметам 0 до n Отказ

Столбцы таблицы соответствуют ограничением веса от 0 до В.

Индекс самой последней клетки таблицы будет:

[n][W]

Значение ячейки с индексом [i] [j] представляет максимальную возможную прибыль при рассмотрении пунктов от 0 до i и общий предел веса как j.

После заполнения таблицы наш ответ будет в самой последней клетке таблицы.

Как заполнить стол?

Давайте начнем с помощью 0-й строки и столбца до 0. Мы сделаем это, потому что 0 ряд означает, что у нас нет объектов, а 0-й столбец означает, что максимальный возможной вес 0.

Теперь для каждой ячейки [I] [J] у нас есть два варианта:

Либо мы включаем объект [I] в нашем окончательном выборе.
Или мы не включаем объект [I] в нашем окончательном выборе.

Как мы решим, включаем ли мы объект [I] в нашем выборе?

Существует два условия, которые должны быть удовлетворены включать объект [I]:

Общий вес после включения объекта [I] должен не превышать Максимальный вес.
Прибыль После включения объекта [I] должно быть Большой по сравнению с когда объект не включен.

Давайте преобразом наше понимание рюкзака 0/1 в код Python.

Код Python для решения 0/1 knaxackack

Давайте создадим таблицу, используя следующий метод понимания списка:

table = [[0 for x in range(W + 1)] for x in range(n + 1)]

Мы будем использовать вложенные для циклов, чтобы пройти через таблицу и заполнить записи в каждой ячейке.

Мы собираемся заполнить таблицу снизу вверх.

for i in range(n + 1): 
        for j in range(W + 1): 
            if i == 0 or j == 0: 
                table[i][j] = 0
            elif wt[i-1] <= j: 
                table[i][j] = max(val[i-1]  
+ table[i-1][j-wt[i-1]],  table[i-1][j]) 
            else: 
                table[i][j] = table[i-1][j]

Давайте сломаем строку кода по линии.

  if i == 0 or j == 0: 
     table[i][j] = 0

Эта часть кода отвечает за настройку 0-й строки и столбца на 0.

 elif wt[i-1] <= j:

Эта линия кода проверяет, что вес объекта I (TH) меньше, чем общий вес допустимой для этой ячейки (J).

 table[i][j] = max(val[i-1]  
+ table[i-1][j-wt[i-1]],  table[i-1][j])

Эта строка кода отвечает за выбор максимума из двух доступных нам вариантов. Мы можем включать объект или исключить его.

Здесь термин Таблица [I – 1] [J] означает, что i-й пункт не включен. Термин val [i – 1] + Таблица [I – 1] [J – WT [I – 1]] Представляет, что элемент ITH включен.

else:
  table[i][j] = table[i-1][j]

Эта часть петли доступна, когда вес объекта ITH больше, чем допустимый предел (j).

Когда мы закончили, заполнив таблицу, мы можем вернуть последнюю ячейку таблицы в качестве ответа.

return table[n][W]

Полный код для решения функции knaxackack

Полный код для функции, который решает knaxackack, приведен ниже:

def knapSack(W, wt, val): 
    n=len(val)
    table = [[0 for x in range(W + 1)] for x in range(n + 1)] 

    for i in range(n + 1): 
        for j in range(W + 1): 
            if i == 0 or j == 0: 
                table[i][j] = 0
            elif wt[i-1] <= j: 
                table[i][j] = max(val[i-1]  
+ table[i-1][j-wt[i-1]],  table[i-1][j]) 
            else: 
                table[i][j] = table[i-1][j] 
  
    return table[n][W]

Давайте попробуем запустить функцию для примера, который мы взяли выше.

val = [50,100,150,200]
wt = [8,16,32,40]
W = 64

print(knapSack(W, wt, val))

Полный код

Вот полный код для работы в вашей системе.

def knapSack(W, wt, val): 
    n=len(val)
    table = [[0 for x in range(W + 1)] for x in range(n + 1)] 

    for i in range(n + 1): 
        for j in range(W + 1): 
            if i == 0 or j == 0: 
                table[i][j] = 0
            elif wt[i-1] <= j: 
                table[i][j] = max(val[i-1]  
+ table[i-1][j-wt[i-1]],  table[i-1][j]) 
            else: 
                table[i][j] = table[i-1][j] 
  
    return table[n][W] 

val = [50,100,150,200]
wt = [8,16,32,40]
W = 64

print(knapSack(W, wt, val))

При запуске кода мы получаем следующий вывод:

Заключение

В этом руководстве было о решении 0/1 Knaxackack, используя динамическое программирование в Python. Мы надеемся, что вы веселились с нами!