Foo and Bar playing a strategical game - algorithm

Question

Foo and Bar is playing a game of strategy. At the start of the game,
there are N apples, placed in a row (in straight line). The apples are
numbered from 1 to N. Each apple has a particular price value.
The price of ith apple is pi for i=1 to N.
In this game,
the players Foo and bar make an alternative move.
In each move, the player does the following:
-If there is only one apple left, the player toss the coin and if its
head, the player takes the first apple among the apples that are
currently present in a row in a straight line , otherwise, the last apple is
taken by the player.
The goal here is to calculate the expected total price value, Foo will get
if Foo Plays First.
Note:
The coin is Unbiased.
Probability of head is 0.50 and similar is the probability of tail.
Total Price Value=summation of price value of all the apples, Foo will get.
Example 1:
N=5
Apple price val:
5 2 3 1 5
Answer is : 11.00
Example 2:
N=6
7 8 2 3 7 8
Answer : 21.250
Example 3:
N=3
1 4 9
First Second Third Foo Total Val
Foo gets 1 Bar gets 4 Foo gets 9 10
Foo gets 1 Bar gets 9 Foo gets 4 5
Foo gets 9 Bar gets 1 Foo gets 4 13
Foo gets 9 Bar gets 4 Foo gets 1 10
probability 0.5 • 0.5 = 0.25.
Expected value (Foo)= (0.25 *10 )+ (0.25 *5) + (0.25*13)+ (0.25*10) = 9.500
I wrote the following code:
#include<iostream>
using namespace std;
double calculate(int start,int end,int num,int current);
int arr[2010];
int main()
{
int T;
scanf("%d",&T);
for(int t=0;t<T;t++)
{
int N;
scanf("%d",&N);
for(int i=0;i<N;i++)
{
scanf("%d",&arr[i]);
}
printf("%.3lf\n",calculate(0,N-1,N/2+N%2,0));
}
return 0;
}
double calculate(int start,int end,int num,int current)
{
if(num==current)
return 0;
double value=0;
value=.5*arr[start]+.5*arr[end]+.5*calculate(start+1,end,num,current+1)+.5*calculate(start,end-1,num,current+1);
return value;
}
But the above code is quite slow ,as the constraints are price of apple<=1000
and 1<=N<=2000 and there are 500 test cases.
How to solve it in must efficient way ?

Answer 1

The first observation you can make is that you don't need all four arguments to calculate - two of them are redundant, i.e. the information they contain is already available in the other two arguments. (By the way, I'm not sure that performance is the only problem - I don't think you simulate the game correctly, maybe you should try it on some small test cases.)
Then, after you've removed the unnecessary parameters and brought them down to two integers from 0 to N - 1, you should read about memoization - it's a way to avoid doing the same calculations multiple times. For example, after you've calculated the answer for start = 2, end = 7, instead of doing the same calculations over and over again every time you need this value, you can store in the 2nd row, 7th column of a two-dimensional array and mark it as found. This way you'll calculate the answer for each subinterval only once, and then use it as something you already know.
This brings the complexity down to O(N^2), which, depending on the implementation and the testing machine, may or may not be fast enough to pass the problem, but is a good start, and has an educational value - dynamic programming and memoization are used pretty often, and you should learn them if you haven't.