Codeforces 442B. Andrey and Problem

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Andrey needs one more problem to conduct a programming contest. He has n friends who are always willing to help. He can ask some of them to come up with a contest problem. Andrey knows one value for each of his fiends — the probability that this friend will come up with a problem if Andrey asks him.

Help Andrey choose people to ask. As he needs only one problem, Andrey is going to be really upset if no one comes up with a problem or if he gets more than one problem from his friends. You need to choose such a set of people that maximizes the chances of Andrey not getting upset.

Input

The first line contains a single integer n (1 ≤ n ≤ 100) — the number of Andrey's friends. The second line contains n real numbers pi (0.0 ≤ pi ≤ 1.0) — the probability that the i-th friend can come up with a problem. The probabilities are given with at most 6 digits after decimal point.

Output

Print a single real number — the probability that Andrey won't get upset at the optimal choice of friends. The answer will be considered valid if it differs from the correct one by at most 10 - 9.

Examples

Input

4

0.1 0.2 0.3 0.8

Output

0.800000000000

Input

2

0.1 0.2

Output

0.260000000000

Note

In the first sample the best strategy for Andrey is to ask only one of his friends, the most reliable one.

In the second sample the best strategy for Andrey is to ask all of his friends to come up with a problem. Then the probability that he will get exactly one problem is 0.1·0.8 + 0.9·0.2 = 0.26.

题目大意

有\(n\)个人，你可以挑出一部分人来向他们要一道题，第\(i\)个人给你题的概率为\(p_i\)，你只需要一道题，多了或少了你都不高兴。问在所有的选人方案里，有且仅有一道题的最大概率是多少？

题解

官方题解很明白不是很清楚你们为什么看不懂

先考虑选出的集合$A = { p_1, p_2, p_3, \ldots , p_n } $

概率\(Ans\)为

\[Ans = \sum_{i=1}^{n} p_i \prod _{j=1}^{n}[i\neq j] \times (1-p_j)
\]

\[=\sum_{i=1}^{n}\frac{p_i}{1-p_i} \prod _{j=1}^{n}(1-p_j)
\]

\[=(\prod_{j=1}^{n}(1-p_j))\times(\sum_{i=1}^{n}\frac{p_i}{1-p_i})
\]

考虑向集合内添加一个新的元素\(p_x\)，对答案的贡献为：

\[\Delta = (\prod_{j=1}^{n}(1-p_j))\times(1-p_x) \times ((\sum_{i=1}^{n}\frac{p_i}{1-p_i}) + \frac{p_x}{1-p_x})) - (\prod_{j=1}^{n}(1-p_j))\times(\sum_{i=1}^{n}\frac{p_i}{1-p_i})
\]

看上去非常乱

记\(P = \prod_{j=1}^{n}(1-p_j),S=\sum_{i=1}^{n}\frac{p_i}{1-p_i}\)

上述式子改写成

\[Ans = P \times S
\]

\[\Delta = P \times (1 - p_x) \times (S + \frac{p_x}{1-p_x}) - P \times S
\]

\[=P \times p_x \times (1 - S)
\]

发现：

引理1：唯有当\(S < 1\)时，\(x\)才会加入集合

那么对于所有满足\(S < 1\)的元素，我们加哪个更好呢？

考虑两个元素\(i,j,i\neq j\),他们的贡献差为：

\[\Delta ^{'}= \Delta_i - \Delta_j
\]

\[=P\times p_i(1 - S) - P \times p_j \times (1-S)
\]

\[=P\times (1-S)\times(p_i - p_j)
\]

由此得到：

引理2：当元素\(i\)比\(j\)更优时，当且仅当\(\Delta ^{'}> 0\)，即\(p_i > p_j\)

算法不难得出：按照\(p_i\)排序，不断往里加，一直加到\((1-S) \leq 0\)为止，即为答案

接下来通过上述结论来证明算法正确的充分性，即算法的是正确答案。

考虑反证法，假设最有答案集合为\(A\),存在元素\(i,j\),满足\(i \in A,j \notin B,p_i < p_j\),那我们把\(i\)从集合\(A\)中去掉，此时一定满足\((1-S) > 0\)（不然最优答案为啥要把\(i\)加进去呢）。根据引理1我们可以把\(j\)加进去，根引理2，加入\(j\)比加入\(i\)更优，与\(A\)为最优矛盾。所以\(j\)应该加入答案。

归纳一下算法就是对的了（唔）

此外还要加个特判

因为\(p_i = 1\)的时候S就挂了。。

所以如果出现\(1\)，答案就是1，直接输出

其实我相当于把官方题解翻译了一遍，加了点自己的东西觉得更好理解

上述证明写法非常不严谨，大家自行脑补严谨的写法

只是做了点微小的工作，谢谢大家

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <map>
#include <cmath>
inline int  max(int a, int b){return a > b ? a : b;}
inline int  min(int a, int b){return a < b ? a : b;}
inline void swap(int &x, int &y){int  tmp = x;x = y;y = tmp;}
inline void read(int &x)
{
    x = 0;char ch = getchar(), c = ch;
    while(ch < '0' || ch > '9') c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
    if(c == '-') x = -x;
}
const int INF = 0x3f3f3f3f;
double a[10000 + 10], S, P;
int n;
bool cmp(double a, double b)
{
	 return a > b;
}
int main()
{
	read(n);
	for(int i = 1;i <= n;++ i)
		scanf("%lf", &a[i]);
	std::sort(a + 1, a + 1 + n, cmp);
	if(a[1] == 1)
	{
		printf("1");
		return 0;
	}
	P = 1, S = 0;
	for(int i = 1;i <= n;++ i)
	{
		if(S < 1)
		{
			P *= 1 - a[i];
			S += a[i] / (1 - a[i]);
		}
	}
	printf("%.10lf", P * S);
	return 0;
}