Problem:
﻿Score : 400 points

Problem Statement

In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.

In the plan developed by the president Takahashi, the trains will run as follows:

A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.

In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.

According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.

Find the maximum possible distance that a train can cover in the run.

Constraints

1 \leq N \leq 100

1 \leq t_i \leq 200

1 \leq v_i \leq 100

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N

Output

Print the maximum possible that a train can cover in the run.

Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.

Sample Input 1

1
100
30

Sample Output 1

2100.000000000000000

The maximum distance is achieved when a train runs as follows:

In the first 30 seconds, it accelerates at a rate of 1m/s^2, covering 450 meters.

In the subsequent 40 seconds, it maintains the velocity of 30m/s, covering 1200 meters.

In the last 30 seconds, it decelerates at the acceleration of -1m/s^2, covering 450 meters.

The total distance covered is 450 + 1200 + 450 = 2100 meters.

Sample Input 2

2
60 50
34 38

Sample Output 2

2632.000000000000000

The maximum distance is achieved when a train runs as follows:

In the first 34 seconds, it accelerates at a rate of 1m/s^2, covering 578 meters.

In the subsequent 26 seconds, it maintains the velocity of 34m/s, covering 884 meters.

In the subsequent 4 seconds, it accelerates at a rate of 1m/s^2, covering 144 meters.

In the subsequent 8 seconds, it maintains the velocity of 38m/s, covering 304 meters.

In the last 38 seconds, it decelerates at the acceleration of -1m/s^2, covering 722 meters.

The total distance covered is 578 + 884 + 144 + 304 + 722 = 2632 meters.

Sample Input 3

3
12 14 2
6 2 7

Sample Output 3

76.000000000000000

The maximum distance is achieved when a train runs as follows:

In the first 6 seconds, it accelerates at a rate of 1m/s^2, covering 18 meters.

In the subsequent 2 seconds, it maintains the velocity of 6m/s, covering 12 meters.

In the subsequent 4 seconds, it decelerates at the acceleration of -1m/s^2, covering 16 meters.

In the subsequent 14 seconds, it maintains the velocity of 2m/s, covering 28 meters.

In the last 2 seconds, it decelerates at the acceleration of -1m/s^2, covering 2 meters.

The total distance covered is 18 + 12 + 16 + 28 + 2 = 76 meters.

Sample Input 4

1
9
10

Sample Output 4

20.250000000000000000

The maximum distance is achieved when a train runs as follows:

In the first 4.5 seconds, it accelerates at a rate of 1m/s^2, covering 10.125 meters.

In the last 4.5 seconds, it decelerates at the acceleration of -1m/s^2, covering 10.125 meters.

The total distance covered is 10.125 + 10.125 = 20.25 meters.

Sample Input 5

10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70

Sample Output 5

20291.000000000000

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<VecDeque<_>>()
        }
    )
}

fn max_v(s:u32, e:u32, v: u32, t: f32) -> f32 {
    let s = s as f32;
    let e = e as f32;
    let v = v as f32;

    if t < s {
        v + (s-t) 
    } else if e < t {
        v + (t - e)
    } else {
        v
    }
}

use std::collections::VecDeque;

fn solve(mut ts: VecDeque<u32>, mut vs: VecDeque<u32>) -> f32 {
    let a = 0;

    ts.push_front(0);
    ts.push_back(0);
    vs.push_front(0);
    vs.push_back(0);

    let total_t: u32 = ts.iter().cloned().sum();
    let mut dist = 0.0;
    let mut last_v = 0.0;

    for t in 1..(total_t*2+1) {
        let t = t as f32 / 2.0;

        let mut min_v = std::f32::MAX;
        let mut acc_t = 0;
        for i in 0..vs.len() {
            let v = vs[i];
            let rt = ts[i];

            let mv = max_v(acc_t, acc_t + rt, v, t);
            if mv < min_v {
                min_v = mv;
            }
            acc_t += rt;
        }
        dist += 0.25*(last_v + min_v);
        last_v = min_v;
    }

    dist
}

fn main() {
    read_line!();

    let ts = parse_vec!(u32);
    let vs = parse_vec!(u32);

    println!("{}", solve(ts ,vs));
}

#[test]
fn solve_test() {
    assert!((solve(vec![100].into_iter().collect::<VecDeque<u32>>(),
                   vec![30].into_iter().collect::<VecDeque<u32>>()) - 2100.0).abs() < 10e-3);

    assert!((solve(vec![60,50].into_iter().collect::<VecDeque<u32>>(),
                   vec![34,38].into_iter().collect::<VecDeque<u32>>()) - 2632.0).abs() < 10e-3);

    assert!((solve(vec![12,14,2].into_iter().collect::<VecDeque<u32>>(),
                   vec![6,2,7].into_iter().collect::<VecDeque<u32>>()) - 76.0).abs() < 10e-3);

}