dynamic-programming

I have removed all the storylines for this question. Q. You are given N numbers. You have to find 2 equal sum sub-sequences, with maximum sum. You don't necessarily need to use all numbers. Eg 1:- 5 1 2 3 4 1 Sub-sequence 1 : 2 3 // sum = 5 Sub-sequence 2 : 4 1 // sum = 5 Possible Sub-sequences with equal sum are {1,2} {3} // sum = 3 {1,3} {4} // sum = 4 {2,3} {4,1} // sum = 5 Out of which 5 is the maximum sum. Eg 2:- 6 1 2 4 5 9 1 Sub-sequence 1 : 2 4 5 // sum = 11 Sub-sequence 2 : 1 9 1 // sum = 11 The maximum sum you can get is 11 Constraints: 5 <= N <= 50 1<= number <=1000 sum of all

An array of length n is given. Find the sum of products of elements of the sub-array. Explanation Array A = [2, 3, 4] of length 3 . Sub-array of length 2 = [2,3], [3,4], [2,4] Product of elements in [2, 3] = 6 Product of elements in [3, 4] = 12 Product of elements in [2, 4] = 8 Sum for subarray of length 2 = 6+12+8 = 26 Similarly, for length 3 , Sum = 24 As, products can be larger for higher lengths of sub-arrays calculate in modulo 1000000007 . What is an efficient way for finding these sums for subarrays of all possible lengths, i.e., 1, 2, 3, ......, n where n is the length of the array. We

In Java, how should I find the closest (or equal) possible sum of an Array's elements to a particular value K? For example, for the array {19,23,41,5,40,36} and K=44, the closest possible sum is 23+19=42. I've been struggling on this for hours; I know almost nothing about dynamic programming. By the way, the array contains only positive numbers. You would typically use dynamic programming for such a problem. However, that essentially boils down to keeping a set of possible sums and adding the input values one by one, as in the following code, and has the same asymptotic running time: O(n K) ,

Consider 2 sequences X[1..m] and Y[1..n]. The memoization algorithm would compute the LCS in time O(m*n). Is there any better algorithm to find out LCS wrt time? I guess memoization done diagonally can give us O(min(m,n)) time complexity. Gene Myers in 1986 came up with a very nice algorithm for this, described here: An O(ND) Difference Algorithm and Its Variations . This algorithm takes time proportional to the edit distance between sequences, so it is much faster when the difference is small. It works by looping over all possible edit distances, starting from 0, until it finds a distance for

Is it "good practice" to create a class like the one below that can handle the memoization process for you? The benefits of memoization are so great (in some cases, like this one, where it drops from 501003 to 1507 function calls and from 1.409 to 0.006 seconds of CPU time on my computer) that it seems a class like this would be useful. However, I've read only negative comments on the usage of eval() . Is this usage of it excusable, given the flexibility this approach offers? This can save any returned value automatically at the cost of losing side effects. Thanks. import cProfile class