dynamic-programming

I want to vectorize the following MATLAB code. I think it must be simple but I'm finding it confusing nevertheless. r = some constant less than m or n [m,n] = size(C); S = zeros(m-r,n-r); for i=1:m-r+1 for j=1:n-r+1 S(i,j) = sum(diag(C(i:i+r-1,j:j+r-1))); end end The code calculates a table of scores, S , for a dynamic programming algorithm, from another score table, C . The diagonal summing is to generate scores for individual pieces of the data used to generate C , for all possible pieces (of size r). Thanks in advance for any answers! Sorry if this one should be obvious... Note The built-in

The case I am working on is dividing a big three-dimensional array of data that I have collected using good coding practises (etc...) and now I need to segment the layers of this array into separate variables for individual processing elsewhere, I can't call my data like this BigData(:,:,n) . So I would like to create a loop where I create new variables like so for i=1:n createVariable('user_' i) = BigData(:,:,i); end How do I do this without writing n new variables by hand every time? user_1 = BigData(:,:,1); user_2 = BigData(:,:,2); user_3 = BigData(:,:,3); . . . Your disclaimer sounds

I´ve got the following assignment. You have a multiset S with of 1<=N<=22 elements. Each element has a positive value of up to 10000000. Assmuming that there are two subsets s1 and s2 of S in which the sum of the values of all the elements of one is equal to the sum of the value of all the elements of the other and it is the highest possible value. I have to return which elements of S would not be included in either of the two subsets. Its probably been solved before, I think its some variant of the Partition problem but I can´t find it. If anyone could point me in the right direction that´d

Given the following Input 10 4 3 5 5 7 Where 10 = Total Score 4 = 4 players 3 = Score by player 1 5 = Score by player 2 5 = Score by player 3 7 = Score by player 4 I am to print players who's combine score adds to total so output can be 1 4 because player 1 + player 4 score = 3 + 7 -> 10 or output can be 2 3 because player 2 + player 3 score = 5 + 5 -> 10 So it is quite similar to a subset sum problem. I am relatively new to dynamic programing but after getting help on stackoverflow and reading dynamic programing tutorials online and watch few videos online for past 3 days. The following code

There is a classic Knapsack problem . My version of this problem is a little different. Given set of items, each with a mass, determine the number of combinations to pack items so that the total weight is less than or equal to a given limit. For example, there is 5 items with mass: 1, 1, 3, 4, 5 . There is a bug with limit = 7 . There are the following combinations: 1 + 3 1 + 4 1 + 5 1 + 1 + 3 1 + 1 + 4 1 + 1 + 5 3 3 + 4 4 5 Is there a way to count number of combinations without brute? This is one solution: items = [1,1,3,4,5] knapsack = [] limit = 7 def print_solutions(current_item, knapsack,

Given N items with values x[1], ..., x[n] and an integer K find a linear time algorithm to arrange these N items in K non empty groups such that in each group the range (difference between minimum and maximum element values/keys in each group) is minimized and therefore the sum of the ranges is minimum. For example given N=4 , K=2 and the elements 1 1 4 3 the minimum range is 1 for groups (1,1) and (4,3) . You can binary search the answer. Assume the optimal answer is x . Now you should verify whether we can group the items into k groups where the maximum difference between the group items is

Given is a N*N grid.Now we need to find a good path of maximum length , where good path is defined as follow : Good path always start from a cell marked as 0 We are only allowed to move Left,Right,Up Or Down If the value of ith cell is say A, then value of next cell in the path must be A+1. Now given these few conditions, I need to find out the length of maximum path that can be made. Also I need to count such paths that are of maximum length. Example : Let N=3 and we have 3*3 matrix as follow : 0 3 2 3 0 1 2 1 0 Then maximum good path length here is 3 and the count of such good paths is 4. 0