Problem:
Score : 100 points

Problem Statement

Let N be a positive odd number.

There are N coins, numbered 1, 2, \ldots, N.
For each i (1 \leq i \leq N), when Coin i is tossed, it comes up heads with probability p_i and tails with probability 1 - p_i.

Taro has tossed all the N coins.
Find the probability of having more heads than tails.

Constraints

N is an odd number.

1 \leq N \leq 2999

p_i is a real number and has two decimal places.

0 < p_i < 1

Input

Input is given from Standard Input in the following format:

N
p_1 p_2 \ldots p_N

Output

Print the probability of having more heads than tails.
The output is considered correct when the absolute error is not greater than 10^{-9}.

Sample Input 1

3
0.30 0.60 0.80

Sample Output 1

0.612

The probability of each case where we have more heads than tails is as follows:

The probability of having (Coin 1, Coin 2, Coin 3) = (Head, Head, Head) is 0.3 × 0.6 × 0.8 = 0.144;

The probability of having (Coin 1, Coin 2, Coin 3) = (Tail, Head, Head) is 0.7 × 0.6 × 0.8 = 0.336;

The probability of having (Coin 1, Coin 2, Coin 3) = (Head, Tail, Head) is 0.3 × 0.4 × 0.8 = 0.096;

The probability of having (Coin 1, Coin 2, Coin 3) = (Head, Head, Tail) is 0.3 × 0.6 × 0.2 = 0.036.

Thus, the probability of having more heads than tails is 0.144 + 0.336 + 0.096 + 0.036 = 0.612.

Sample Input 2

1
0.50

Sample Output 2

0.5

Outputs such as 0.500, 0.500000001 and 0.499999999 are also considered correct.

Sample Input 3

5
0.42 0.01 0.42 0.99 0.42

Sample Output 3

0.3821815872

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String args[]) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int N = sc.nextInt();
        // Ah Errichto clever clever - just read the p when you're using it!
//        double[] p = new double[N];
//        for (int i = 0; i < p.length; i++) {
//            p[i] = sc.nextDouble();
//        }

        double[] dp = new double[N + 1];
        // dp[i] stores probability to get i heads, N - i tails
        // We implicitly store, with how many coins can we achieve this outcome
        // But really, we just go through all the coins and transition
        // the current heads to the new state, of using 1 more coin.
        dp[0] = 1;
        // A way to think about what's happening to the distribution of coins over time
        // is that, for every probability that's already in the dp array,
        // it is splitting itself and moving into two points:
        // Either it generates a head, which multiplies by p and sends it to the next
        // level, or it generates a tail * (1 - p), and changes the prob of the current
        // head count. Notice that this nets a sum of (p + 1 - p) * dp[heads].
        // However, when getting a tail, we don't add, but rather REPLACE the old
        // value of dp[heads]. So, what's happening is we add (p + 1 - p) * dp[heads],
        // but subtracted the old dp[heads], since that's no longer possible!
        for (int coin = 0; coin < N; coin++) {
            double p = sc.nextDouble();
            for (int heads = N - 1; heads >= 0; heads--) {
                // We must go downwards, because at each position,
                // we must rely on the answer for a smaller problem, then
                // update us!

                // There's a new way to reach the next coin
                dp[heads + 1] += dp[heads] * p;
                // In order to preserve this # heads, it's harder
                dp[heads] *= (1 - p);
            }
        }
        double sum = 0;
        for (int heads = N / 2 + 1; heads <= N; heads++) {
            sum += dp[heads];
        }
        out.println(sum);
        out.close();
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        FastScanner(FileReader s) {
            br = new BufferedReader(s);
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException { return br.readLine(); }

        double nextDouble() throws IOException { return Double.parseDouble(next()); }

        int nextInt() throws IOException { return Integer.parseInt(next()); }

        long nextLong() throws IOException { return Long.parseLong(next()); }
    }
}