Programación competitiva: ¿cómo se soluciona este problema en el Quora Haqathon?

Valor esperado = [matemática] \ suma \ límites_ {i = 1} ^ n P {i} * T {i} [/ matemática]
Donde P i es Probabilidad de que la prueba i-ésima sea ​​la primera prueba en fallar. Y Ti es el momento hasta que se ejecutó la i-ésima prueba. n es el número de pruebas.


Debe encontrar el valor esperado para todas las permutaciones de pruebas. Es decir, para todos los posibles pedidos de las pruebas y luego elegir el valor mínimo esperado.


para el ejemplo dado en el problema, con tres pruebas. Veamos cuáles son los valores esperados para todas las permutaciones posibles:
F = falla
P = pasa
X = ni siquiera corrió
1)
3,7,9
0.1,0.5,0.2

F XX = 0.9 * 3 = 2.7
P F X = 0.1 * 0.5 * (3 + 7) = 0.5
PP F = 0.1 * 0.5 * 0.8 * (3 + 7 + 9) = 0.76
PPP = 0.1 * 0.5 * 0.2 * (3 + 7 + 9) = 0.19
suma = 4.15

2)
3,9,7
0.1,0.2,0.5

F XX = 0.9 * 3 = 2.7
P F X = 0.1 * 0.8 * (3 + 9) = 0.96
PP F + PPP = 0.1 * 0.2 * (19) = 0.38
suma = 4.04


Del mismo modo, calcula para las 6 permutaciones en este caso y encuentra el mínimo entre ellas.

4.04 viene como respuesta de (2) arriba.


Así es como lo haces desde el primer principio. ¡Mirando las restricciones, puedes ver que haciendo 100! las permutaciones y encontrar el mínimo entre ellas no se escalarán en el tiempo. Por lo tanto, necesita un método un poco más inteligente que simplemente hacerlo por fuerza bruta. ¡Que la fuerza esté con usted!

Aquí en este problema, tenemos que ordenar los casos de prueba de manera que el tiempo total esperado sea mínimo.
Primero veremos que dado el orden óptimo, cómo obtener el tiempo esperado.
Tenga en cuenta que la explicación es para n = 4, pero la misma lógica se aplica a cualquier n general.
Deje que el orden óptimo sea (t1, p1), (t1, p2), (t3, p3), (t4, p4)
El tiempo total esperado es
T = t1 * (1-p1) + (t1 + t2) * p1 * (1-p2) + (t1 + t2 + t3) * p1 * p2 * (1-p3) + (t1 + t2 + t3 + t4 ) * p1 * p2 * p3 * (1-p4) + (t1 + t2 + t3 + t4) * p1 * p2 * p3 * p4
Al simplificar la expresión anterior obtenemos
T = t1 + t2 * p1 + t3 * p1 * p2 + t4 * p1 * p2 * p3
Por lo tanto, ahora conocemos la expresión para el tiempo total esperado.
Ahora veremos cómo ordenar (u ordenar) todos los casos de prueba de manera que el tiempo esperado T sea ​​mínimo.
Sea (t1, p1), (t2, p2), (t3, p3), (t4, p4) el orden óptimo, de modo que el tiempo esperado T sea mínimo, por lo que el tiempo esperado será mayor que T para cualquier otro orden.
El tiempo esperado T1 será mayor para el orden (t1, p1), (t3, p3), (t2, p2), (t4, p4) (es decir, intercambiando dos pares del medio)
Ya lo sabemos
T = t1 + t2 * p1 + t3 * p1 * p2 + t4 * p1 * p2 * p3
T1 = t1 + t3 * p1 + t2 * p1 * p3 + t4 * p1 * p2 * p3
Por lo tanto, T da
t1 + t2 * p1 + t3 * p1 * p2 + t4 * p1 * p2 * p3 Al simplificar obtenemos
t2 + t3 * p2 t2 * (1 -p3) t2 / (1-p2)
De este resultado podemos observar que se obtiene un orden óptimo cuando todos los pares (ti, pi) se ordenan de acuerdo con la expresión ti / (1-pi)

Por lo tanto, todo lo que necesitamos hacer es ordenar todas las tuplas de acuerdo con ti / (1-pi) y calcular el tiempo esperado de acuerdo con la expresión derivada anteriormente.

#include
usando el espacio de nombres estándar;
#define pi pair
#define pb push_back
#define mp make_pair
#define s second
#define f primero
func bool (pi a, pi b) {
doble c, d;
c = a.f + bf * como;
d = b.f + af * bs;
retorno c }
int main () {
int n;
cin >> n;
pi a [n];
para (int i = 0; i > a [i] .f >> a [i] .s;
sort (a, a + n, func);
doble ans = 0;
int s = 0;
doble p = 1;
para (int i = 0; i s + = a [i] .f;
ans = ans + s * p * (1.0-a [i] .s);
p * = a [i] .s;
}
ans = ans + s * p;
printf (“%. 10f”, ans);
}