Problem:
E: Entangled with Lottery

ICPC で良い成績を収めるには修行が欠かせない．うさぎは ICPC で勝ちたいので，今日も修行をすることにした．

今日の修行は，あみだくじを利用して，未来を読む力をつけて運気を高めようというものである．もちろん直感に頼るだけでなく，綿密な確率計算も欠かせない．

今回考えるあみだくじは，長さ H + 1 センチメートルの縦棒 N 本からなる．うさぎは棒の上部を見て，N 本のうち 1 本を選ぶことになる．棒の下部には，左から P 本目の棒の場所にのみ「当たり」と書かれている．あみだくじにはいくつかの横棒が含まれる．横棒の配置に関して，以下の条件を考えよう．

各横棒は，a を 1 以上 H 以下の整数として，縦棒の上端から a センチメートルの高さにある．

各横棒は，隣り合った 2 本の縦棒のみを結ぶ．

同じ高さには複数の横棒は存在しない．

うさぎはこれらの条件を満たすように M 本の横棒を引いた．あいにくうさぎは記憶力が良いので，当たりの位置や横棒の位置をすべて覚えてしまっており，あみだくじを楽しめない．そこで友達のねこにさらに横棒を追加してもらうことにした．

まず，うさぎは当たりを狙って N 本の棒のうち 1 本を選ぶ．その後，ねこは以下の操作をちょうど K 回行う．

横棒を追加しても上で指定された条件を満たすような場所のうち 1 箇所を無作為に選ぶ．ここで，どの場所も等確率で選ばれるものとする．選んだ場所に横棒を追加する．

そして，うさぎが選んだ棒が当たりであったかを判定する．棒の辿り方は通常のあみだくじと同様である (横棒に出会うたびに隣の縦棒に移る)．うさぎは，可能な限り当たりとなる確率を高くしたい．

Input

H N P M K
A1 B1
...
AM BM

Ai, Bi (1 ≤ i ≤ M) はうさぎが引いた横棒のうち i 番目のものが，縦棒の上端から Ai センチメートルの高さにあり，左から Bi 本目の縦棒と左から Bi + 1 本目の縦棒を結ぶことを表す整数である．

2 ≤ H ≤ 500，2 ≤ N ≤ 100，1 ≤ P ≤ N，1 ≤ M ≤ 100，1 ≤ K ≤ 100，M + K ≤ H，1 ≤ A1 < A2 < ... < AM ≤ H，1 ≤ Bi ≤ N - 1 を満たす．

Output

当たりとなる確率が最大となるようにうさぎが棒を選んだときの，当たりとなる確率を 1 行に出力せよ．10-6 以下の絶対誤差が許容される．

Sample Input 1

9 4 3 2 1
2 1
7 3

Sample Output 1

0.571428571

Sample Input 2

9 4 3 2 3
2 1
7 3

Sample Output 2

0.375661376

Solution in Rust (judge verdict: Accepted)

extern crate core;

use std::fmt;
use std::cmp::{max, min};
macro_rules! read_line{
    () => {{
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).ok();
        line
    }};
    (delimiter: ' ') => {
        read_line!().split_whitespace().map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (delimiter: $p:expr) => {
        read_line!().split($p).map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (' ') => {
        read_line!(delimiter: ' ')
    };
    ($delimiter:expr) => {
        read_line!(delimiter: $delimiter)
    };
    (' '; $ty:ty) => {
        read_line!().split_whitespace().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
    ($delimiter:expr; $ty:ty) => {
        read_line!($delimiter).into_iter().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
}
macro_rules! let_all {
    ($($n:ident:$t:ty),*) => {
        let line = read_line!(delimiter: ' ');
        let mut iter = line.iter();
        $(let $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
    };
}
fn solve(memo:&mut Vec<Vec<Vec<f64>>>, p: usize, n: usize, current: usize, h: usize, k: usize, free: usize, borders: &Vec<usize>) -> f64 {
    if k > free {
        0_f64
    }else if h == memo.len() {
        if p == current {
            1_f64
        }else {
            0_f64
        }
    }else if memo[h][current][k] < 0_f64 {
        let r = match borders[h] {
            b if b == current => {
                solve(memo, p, n, current + 1, h + 1, k, free, borders)
            }
            b if b + 1 == current => {
                solve(memo, p, n, current - 1, h + 1, k, free,borders)
            }
            b if b == n => {
                if k == 0 {
                    solve(memo, p, n, current, h + 1, k, free - 1, borders)
                }else {
                    let choice = (k as f64) / free as f64;
                    let prob = 1_f64 / (n - 1) as f64;
                    if current == 0 {
                        choice * ((1_f64 - prob) * solve(memo, p, n, current, h + 1, k - 1, free - 1, borders) + prob * solve(memo, p, n, current + 1, h + 1, k - 1, free - 1, borders)) +
                            (1_f64 - choice) * solve(memo, p, n, current, h + 1, k, free - 1, borders)
                    }else if current == n - 1 {
                        choice * ((1_f64 - prob) * solve(memo, p, n, current, h + 1, k - 1, free - 1, borders) + prob * solve(memo, p, n, current - 1, h + 1, k - 1, free - 1, borders)) +
                            (1_f64 - choice) * solve(memo, p, n, current, h + 1, k, free - 1, borders)
                    }else {
                        choice * ((1_f64 - prob * 2_f64) * solve(memo, p, n, current, h + 1, k - 1, free - 1, borders) + prob * (solve(memo, p, n, current - 1, h + 1, k - 1, free - 1, borders) + solve(memo, p, n, current + 1, h + 1, k - 1, free - 1, borders))) +
                            (1_f64 - choice) * solve(memo, p, n, current, h + 1, k, free - 1, borders)
                    }
                }
            }
            _ => solve(memo, p, n, current, h + 1, k, free,borders)
        };
        memo[h][current][k] = r;
        r
    }else {
        memo[h][current][k]
    }
}
fn main() {
    let_all!(h: usize, n: usize, p: usize, m: usize, k: usize);
    let mut borders: Vec<usize> = vec![n; h];
    for _ in 0 .. m {
        let_all!(a: usize, b: usize);
        borders[a - 1] = b - 1;
    }
    let borders = borders;
    let mut memo = vec![vec![vec![-1_f64; k + 1]; n]; h];
    let mut max = 0_f64;
    for i in 0 .. n {
        let r = solve(&mut memo, p - 1, n, i, 0, k, h - m, &borders);
        if r > max {
            max = r;
        }
    }
    println!("{:.*}", 15, max);
}