Problem:
地震 (Earthquakes)

E869120 君は地震が苦手です。

具体的には、ある作業をしている時に震度 $p$ の地震が発生した際、その作業のパフォーマンスが $10 \times p$ パーセント低下します。

昨日、$N$ 回地震が発生しました。より具体的に言うと、昨日の i 回目の地震は時刻 $T_i$ に発生し、その震度は $A_i$ でした。

ここで $Q$ 個の質問が与えられます。$i$ 個目の質問の内容は以下の通りです。

E869120 君が時刻 $L_i$ から時刻 $R_i$ まで作業をした時、最終的な作業のパフォーマンスの値はいくつになるでしょうか？

ただし、作業開始時のパフォーマンスは $1000000000 \ (= 10^9)$ であり、地震以外に作業のパフォ―マンスに影響を及ぼすものはないものとします。

また、作業開始時、終了時と同時に地震が発生していることはありません。

入力

入力は以下の形式で標準入力から与えられる。

$N$
$T_1$ $A_1$
$T_2$ $A_2$
$T_3$ $A_3$
$\ldots$
$T_N$ $A_N$
$Q$
$L_1$ $R_1$
$L_2$ $R_2$
$L_3$ $R_3$
$\ldots$
$L_Q$ $R_Q$

出力

質問 $1, 2, 3, \dots, Q$ の答えをこの順に改行区切りで出力しなさい。

ただし、最後には改行を入れること。

なお、想定解答との絶対誤差又は相対誤差が $10^{-7}$ 以内ならば正解と判定される。

制約

$1 \leq N \leq 100000 \ (= 10^5)$

$1 \leq Q \leq 100000 \ (= 10^5)$

$0 \leq A_i \leq 7$

$1 \leq T_1 < T_2 < \cdots < T_N \leq 1000000000 \ (= 10^9)$

$1 \leq L_i < R_i \leq 1000000000 \ (= 10^9)$

作業開始時刻ちょうどや作業終了時刻ちょうどに、地震が発生するような入力は与えられない。

入力は全て整数である。

入力例1

3
3 3
5 4
8 1
2
1 4
4 9

出力例1

700000000.000000000000
539999999.999999880791

どの質問に対しても、出力された値が実際の答えの値との絶対誤差または相対誤差が $10^{-7}$ 以内であれば、正解と判定されます。

入力例2

3
3 1
41 5
92 6
2
5 35
8 97

出力例2

1000000000.000000000000
200000000.000000059605

入力例3

10
176149409 6
272323398 6
280173589 0
374879716 5
402263621 5
498152735 0
639318228 6
641750638 3
764022785 2
939252868 5
10
40529600 224871240
537110257 584835100
409292125 704323206
674752453 740931787
511335734 793975505
320036645 530705208
527941292 660218875
326908007 473745741
428255750 654430923
590875206 623136989

出力例3

400000000.000000000000
1000000000.000000000000
280000000.000000059605
1000000000.000000000000
224000000.000000089407
250000000.000000000000
280000000.000000059605
250000000.000000000000
280000000.000000059605
1000000000.000000000000

Solution in Rust (judge verdict: Accepted)

// ---------- begin SegmentTree Point update Range query ----------
mod segment_tree {
    pub struct PURQ<T: Clone, F: Fn(T, T) -> T> {
        n: usize,
        a: Vec<T>,
        id: T,
        op: F,
    }
    #[allow(dead_code)]
    impl<T: Clone, F: Fn(T, T) -> T> PURQ<T, F> {
        pub fn new(n: usize, id: T, op: F) -> PURQ<T, F> {
            let mut k = 1;
            while k < n {
                k *= 2;
            }
            PURQ {
                n: k,
                a: vec![id.clone(); 2 * k],
                id: id,
                op: op,
            }
        }
        pub fn update(&mut self, x: usize, v: T) {
            let mut k = self.n + x;
            let a = &mut self.a;
            a[k] = v;
            k >>= 1;
            while k > 0 {
                a[k] = (self.op)(a[2 * k].clone(), a[2 * k + 1].clone());
                k >>= 1;
            }
        }
        pub fn update_tmp(&mut self, x: usize, v: T) {
            self.a[x + self.n] = v;
        }
        pub fn update_all(&mut self) {
            for k in (1..(self.n)).rev() {
                self.a[k] = (self.op)(self.a[2 * k].clone(), self.a[2 * k + 1].clone());
            }
        }
        pub fn find(&self, mut l: usize, mut r: usize) -> T {
            let mut p = self.id.clone();
            let mut q = self.id.clone();
            l += self.n;
            r += self.n;
            while l < r {
                if (l & 1) == 1 {
                    p = (self.op)(p, self.a[l].clone());
                    l += 1;
                }
                if (r & 1) == 1 {
                    r -= 1;
                    q = (self.op)(self.a[r].clone(), q);
                }
                l >>= 1;
                r >>= 1;
            }
            (self.op)(p, q)
        }
    }
}
// ---------- end SegmentTree Point update Range query ----------
//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

use std::io::Write;

fn run() {
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    input! {
        n: usize,
        a: [(usize, usize); n],
        q: usize,
        ask: [(usize, usize); q],
    }
    let mut z = vec![];
    for a in a.iter() {
        z.push(a.0);
    }
    for p in ask.iter() {
        z.push(p.1);
        z.push(p.0);
    }
    z.sort();
    z.dedup();
    let mut seg = segment_tree::PURQ::new(z.len(), 1.0, |a, b| a * b);
    for a in a.iter() {
        let k = z.binary_search(&a.0).unwrap();
        let q = 1.0 - a.1 as f64 / 10 as f64;
        seg.update_tmp(k, q);
    }
    seg.update_all();
    for (l, r) in ask {
        let l = z.binary_search(&l).unwrap();
        let r = z.binary_search(&r).unwrap();
        let ans = seg.find(l, r) * 1000000000f64;
        writeln!(out, "{:.8}", ans).ok();
    }
}

fn main() {
    run();
}