dynamic-programming

Problem Statement: There is a broken calculator. Only a few of the digits [ 0 to 9 ] and operators [ +, -, *, / ] are working. A req no. needs to be formed using the working digits and the operators. Each press on the keyboard is called an operation. = operator is always working and is used when the req no. is formed using operators. -1 needs to be printed in case the req no. cannot be formed using the digits and the operators provided OR exceeds the max no. of operations allowed. At no point in time during the calculation of the result, the no. should become negative or exceed 999 [ 0 <=

I am looking for an answer to the following problem. Given a set of integers (no duplicates) and a sum, find all possible combinations of the set's elements summing up to the sum. Solutions order does not matter (solutions {2, 2, 3} and {3, 2 ,2} are equal). Please note that the final combination does not need to be a set, as it can contain duplicates. Example: Set {2,3,5} Sum 10 Result: {2, 2, 2, 2, 2}, {2, 2, 3, 3}, {2, 3, 5}, {5, 5} I've looked at Subset Sum problem as well as Coin Change problem, but couldn't adapt them to suit my needs. I am not really familiar with dynamic programming,

We have an array of N elements. I have to choose K elements from this array(you can't take an element with index that is greater than the index of the element of the next one) in such a way that the sum abs(a1-a0)+abs(a2-a1)+...+(ak-ak-1) is maximized. My idea is 2d DP and goes like this: The solution that involves taking the n -th element while having taken k elements is the maximum of the solutions where element with index j smaller than i is the last one, j from k-1 , j<i plus taking the abs(numbers[n]-numbers[j]) . Here is my code. Where is my mistake? import java.io.BufferedReader; import

I know that: int fib(int n) { if (n == 0 || n == 1) return 1; return fib(n − 1)+ fib(n − 2); } when n=5，fib(5) evaluates as: fib(5) fib(4) + fib(3) (fib(3) + fib(2)) + (fib(2) + fib(1)) ((fib(2) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1)) (((fib(1) + fib(0)) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1)) Notice that each base element being used for several times, is there a way to use map to store the previous value and simply do fib(n − 1) + fib（n − 2)? In C++, the two solutions at your disposal that would save you time are the dynamic programming approach and

I have two kind of coins (unlimited coins of each type). The values of these two coins are x and y . I have to pay a bill of amount B . What minimum amount i will need to pay as tip . tip can be any value >=0 The objective is to minimize the tip. I just was thinking about the Dynamic programming approach.Or any Faster method. Please help. function minTip(x,y,B){ if(z<=0) return -z; return minimum( minTip(x,y,B-x),minTip(x,y,B-y) ); } Can any one help with the DP approach.?? Paul Hankin You don't need DP to solve this. First, note that you may as well assume the coins are coprime. Because if