Random Events CodeForces - 1461C

Ron is a happy owner of a permutation a of length n.

A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).

Ron’s permutation is subjected to m experiments of the following type: (ri, pi). This means that elements in range [1,ri] (in other words, the prefix of length ri) have to be sorted in ascending order with the probability of pi. All experiments are performed in the same order in which they are specified in the input data.

As an example, let’s take a look at a permutation [4,2,1,5,3] and an experiment (3,0.6). After such an experiment with the probability of 60% the permutation will assume the form [1,2,4,5,3] and with a 40% probability it will remain unchanged.

You have to determine the probability of the permutation becoming completely sorted in ascending order after m experiments.

Input
Each test contains one or more test cases. The first line contains the number of test cases t (1≤t≤100).

The first line of each test case contains two integers n and m (1≤n,m≤105) — the length of the permutation and the number of experiments, respectively.

The second line of each test case contains n integers a1,a2,…,an (1≤ai≤n) — contents of the permutation.

The following m lines of each test case each contain an integer ri and a real number pi (1≤ri≤n,0≤pi≤1) — the length of the prefix and the probability of it being sorted. All probabilities are given with at most 6 decimal places.

It is guaranteed that the sum of n and the sum of m does not exceed 105 (∑n,∑m≤105).

Output
For each test case, print a single number — the probability that after all experiments the permutation becomes sorted in ascending order. Your answer will be considered correct if its absolute or relative error does not exceed 10−6.

Formally, let your answer be a, and the jury’s answer be b. Your answer is accepted if and only if |a−b|max(1,|b|)≤10−6.

Example

Input

4
4 3
4 3 2 1
1 0.3
3 1
4 0.6
5 3
4 2 1 3 5
3 0.8
4 0.6
5 0.3
6 5
1 3 2 4 5 6
4 0.9
5 0.3
2 0.4
6 0.7
3 0.5
4 2
1 2 3 4
2 0.5
4 0.1

Output

0.600000
0.720000
0.989500
1.000000

Note
Explanation of the first test case: It can be demonstrated that whether the final permutation is sorted or not depends solely on sorting being performed in the (4,0.6) experiment.

題意：

給一個含有n個元素的陣列，在給出m個R和P，R表示的是陣列中的任意一個元素，P表示的是在這個陣列中從小到大排好前R個數的成功概率
本題要求的是排好所有數的成功概率（成功概率=1-失敗概率）

Ps：成功率是某一段從小到大排序的成功概率。

思路：

先將給的陣列存在另外一個陣列中，對另外一個陣列進行排序，從後往前遍歷，記錄第一個不相等的數的下標，這表示後面的數在原給陣列序列中已經排好序，我們不需再去計算後面相同的成功率，只需要去計算進行排序的那一段的成功概率即可 計算某一段的成功概率，即計算R>=這一段序列下標的失敗率（也就是1-成功率）可能有多個，然後相乘求概率，最後用1-失敗概率得到的就是題目所求。

程式碼：

#include<stdio.h>
#include<algorithm>
using namespace std;
int a[100010],b[100010];
int c[100010];
double d[100010];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        for(int i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i]; //把a陣列存在b陣列中，對b陣列進行排序
        }
        for(int i=0; i<m; i++)
            scanf("%d %lf",&c[i],&d[i]);
        sort(b,b+n);
        int minn=-1;
        for(int i=n-1; i>=0; i--)
        {
            if(b[i]!=a[i])
            {
                minn=i;  //從後往前遍歷找出第一個不相等的數，記錄下標
                break;
            }
        }
        if(minn==-1)  //原來給的序列就是排好序的序列，直接輸出1即可
            printf("1.000000\n");
        else
        {
            double s=1;
        for(int i=0;i<m;i++)
        {
            if(c[i]>minn) //計算最終的失敗概率
            {
                s=s*(1-d[i]);//失敗概率=1-成功概率，多個的情況下是相乘
            }
        }
        printf("%f\n",1-s); //最後輸出成功概率，即1-失敗概率
        }
    }
    return 0;
}