I've coded up the 0-1 Knapsack problem in Haskell. I'm fairly proud about the laziness and level of generality achieved so far.

I start by providing functions for creating and dealing with a lazy 2d matrix.

mkList f = map f [0..] mkTable f = mkList (\i -> mkList (\j -> f i j)) tableIndex table i j = table !! i !! j

I then make a specific table for a given knapsack problem

knapsackTable = mkTable f where f 0 _ = 0 f _ 0 = 0 f i j | ws!!i > j = leaveI | otherwise = max takeI leaveI where takeI = tableIndex knapsackTable (i-1) (j-(ws!!i)) + vs!!i leaveI = tableIndex knapsackTable (i-1) j -- weight value pairs; item i has weight ws!!i and value vs!!i ws = [0,1,2, 5, 6, 7] -- weights vs = [0,1,7,11,21,31] -- values

And finish off with a couple helper functions for looking at the table

viewTable table maxI maxJ = take (maxI+1) . map (take (maxJ+1)) $ table printTable table maxI maxJ = mapM_ print $ viewTable table maxI maxJ

This much was pretty easy. But I want to take it a step further.

I want a better data structure for the table. Ideally, it should be

Unboxed (immutable) [edit] never mind this

[edit] never mind this Lazy

Unbounded

O(1) time to construct

time to construct O(1) time complexity for looking up a given entry,

(more realistically, at worst O(log n) , where n is i*j for looking up the entry at row i, column j)

Bonus points if you can explain why/how your solution satisfies these ideals.

Also bonus points if you can further generalize knapsackTable , and prove that it is efficient.

In improving the data structure you should try to satisfy the following goals:

If I ask for the solution where the maximum weight is 10 (in my current code, that would be indexTable knapsackTable 5 10 , the 5 means include items 1-5) only the minimal amount of work necessary should be performed. Ideally this means no O(i*j) work for forcing the spine of each row of the table to necessary column length. You could say this isn't "true" DP, if you believe DP means evaluating the entirety of the table.

, the 5 means include items 1-5) only the minimal amount of work necessary should be performed. Ideally this means no work for forcing the spine of each row of the table to necessary column length. You could say this isn't "true" DP, if you believe DP means evaluating the entirety of the table. If I ask for the entire table to be printed (something like printTable knapsackTable 5 10 ), the values of each entry should be computed once and only once. The values of a given cell should depend on the values of other cells (DP style: the idea being, never recompute the same subproblem twice)

Ideas:

Data.Array bounded :(

UArray strict :(

Memoization techniques (SO question about DP in Haskell) this might work

Answers that make some compromises to my stated ideals will be upvoted (by me, anyways) as long as they are informative. The answer with the least compromises will probably be the "accepted" one.