Reg : Knapsack problem - [Off Topic] -

Question

Hi All,
Few days back, there was a post which was a practical implementation of the 'Knapsack Problem'.
And, I remember somebody actually posted a query which solved this.
Can anybody please give me the link for it?
Or, if have the query?
I searched the OTN but not getting the post.
Thanks.
Ranit B.

Answer 1

SQL isn't the best tool for the task, but.... And there are many variations of knapsack task. Anyway, below is combination (MODEL + hierarchical) solution I posted on one of SQL forums while back for the following knapsack task:
There are n items. We know weight and cost of each item. Task is to fill knapsack with items so that total weight doesn't exceed knapsack weight capacity and get max possible total cost.
DROP TABLE knapsack PURGE;
CREATE TABLE knapsack(
                      item_number NUMBER PRIMARY KEY,
                      volume      NUMBER NOT NULL,
                      value       NUMBER NOT NULL
INSERT INTO knapsack VALUES(1, 77, 2);
INSERT INTO knapsack VALUES(2, 99, 1);
INSERT INTO knapsack VALUES(3, 19, 3);
INSERT INTO knapsack VALUES(4, 91, 1);
INSERT INTO knapsack VALUES(5,  6, 3);
INSERT INTO knapsack VALUES(6,  6, 1);
INSERT INTO knapsack VALUES(7,  3, 1);
INSERT INTO knapsack VALUES(8, 92, 6);
COMMIT;
VARIABLE capacity NUMBER;
EXEC :capacity := 92;
SELECT  'Will take items ' ||
          regexp_replace(
                         trim(sys_connect_by_path(case max_item_mask when 0 then null else item_number end,' ')),
                         ' +',
                        ) ||
          '. Total value will be ' || max_total_value || ' (' ||
          regexp_replace(
                         trim(sys_connect_by_path(case max_item_mask when 0 then null else value end,' ')),
                         ' +',
                         '+'
                        ) ||
          '). Total volume will be ' || max_total_volume || ' (' ||
          regexp_replace(
                         trim(sys_connect_by_path(case max_item_mask when 0 then null else volume end,' ')),
                         ' +',
                         '+'
                        ) || '). Total iteration count is ' || (iteration_cnt + 1) || '.' best_pick
  FROM  (
         SELECT  i item_number,
                 max_item_mask,
                 max_total_value,
                 max_total_volume,
                 value,
                 volume,
                 iteration_cnt
           FROM  knapsack
           MODEL
             DIMENSION BY(
                          item_number i
             MEASURES(
                      volume,
                      value,
                      count(*) over() cnt,
                      0 item_mask,
                      0 current_volume,
                      0 current_value,
                      0 total_volume,
                      0 total_value,
                      0 max_total_value,
                      0 max_total_volume,
                      0 max_item_mask,
                      1 item_set_mask,
                      0 iteration_cnt
             RULES ITERATE(1e9) UNTIL(item_set_mask[1] >= power(2,cnt[1]))
                item_mask[any]        = bitand(item_set_mask[1],power(2,cv(i) - 1)),
                current_volume[any]   = sign(item_mask[cv(i)]) * volume[cv(i)],
                current_value[any]    = sign(item_mask[cv(i)]) * value[cv(i)],
                total_volume[1]       = sum(current_volume)[any],
                total_value[1]        = sum(current_value)[any],
                max_item_mask[any]    = case
                                           when     total_volume[1] <= :capacity
                                                and
                                                    max_total_value[1] < total_value[1]
                                             then item_mask[cv()]
                                           else max_item_mask[cv()]
                                         end,
                max_total_volume[any] = case
                                          when     total_volume[1] <= :capacity
                                               and
                                                   max_total_value[1] < total_value[1]
                                           then total_volume[1]
                                         else
                                           max_total_volume[1]
                                       end,
                max_total_value[any] = case
                                         when total_volume[1] <= :capacity
                                           then greatest(max_total_value[1],total_value[1])
                                         else max_total_value[1]
                                       end,
                item_set_mask[1]     = case
                                         when total_volume[1] >= :capacity
                                           then item_set_mask[1] + min(case when item_mask > 0 then item_mask else null end)[any]
                                         else item_set_mask[1] + 1
                                       end,
                iteration_cnt[any]   = iteration_number
  WHERE CONNECT_BY_ISLEAF = 1
  START WITH item_number  = 1
  CONNECT BY item_number  = PRIOR item_number + 1
BEST_PICK
Will take items 3, 5, 6, 7. Total value will be 8 (3+3+1+1). Total volume will b
e 34 (19+6+6+3). Total iteration count is 59.
SQL> Keep in mind, solution is "optimized" to skip combinations when we already are at or over max capacity.
SY.