#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <utility>
#include <functional>
#include <iomanip>
#include <typeinfo>
#include <iterator>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <tuple>
#include <map>
#include <set>
#include <numeric>
using namespace std;

#define all(container) container.begin(), container.end()
#define sortall(container) (sort(container.begin(), container.end()))
#define yn(cond) ((cond) ? (cout << "Yes" << endl) : (cout << "No" << endl))
#define YN(cond) ((cond) ? (cout << "YES" << endl) : (cout << "NO" << endl))
#define LLONG_MAX numeric_limits<long long>::max()
#define INT_MAX numeric_limits<int>::max()

typedef long long       ll;
typedef vector<int>     vi;
typedef vector<ll>      vll;
typedef vector<double>  vd;
typedef vector<bool>    vb;
typedef vector<string>  vs;
typedef vector<char>    vc;
typedef pair<int, int>  pii;
typedef pair<ll, ll>    pll;
typedef vector<pii>     vpii;
typedef vector<pll>     vpll;
typedef vector<vll>		vvll;
typedef vector<vi>		vvi;
typedef vector<vb>		vvb;
typedef vector<vc>		vvc;

typedef struct edge_ {
	ll to;
	ll cost;
} edge;

typedef struct point_ {
	ll x, y;
	point_(ll x = 0, ll y = 0) : x(x), y(y) {}
} point;

constexpr double	PI = 3.14159265358979323846;
constexpr ll		INF = 1 << 15;
constexpr ll		MOD = (ll)1e9 + 7;
constexpr double	EPS = 1e-7;
constexpr int		dy4[4] = { 0, 1, 0, -1 };
constexpr int		dx4[4] = { 1, 0, -1, 0 };
constexpr int		dy8[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
constexpr int		dx8[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };

template<typename T>
istream& operator >> (istream& is, vector<T>& vec) {
	for (T& x : vec) is >> x;
	return is;
}

template<typename T>
ostream& operator << (ostream& os, const vector<T>& vec) {
	for (const T& x : vec) os << x << " ";
	return os;
}

template<typename S, typename T>
istream& operator >> (istream& is, pair<S, T>& p) {
	is >> p.first >> p.second;
	return is;
}

istream& operator >> (istream& is, point& p) {
	is >> p.x >> p.y;
	return is;
}

template<typename S, typename T>
ostream& operator << (ostream& os, const pair<S, T>& p) {
	os << "{" << p.first << " " << p.second << "}";
	return os;
}

ostream& operator << (ostream& os, const point& p) {
	os << "(" << p.x << " " << p.y << ")";
	return os;
}


template <typename T>
void vecOutPadding(vector<T>& vec, string pad = " ") {
	for (const T& elem : vec)
		cout << elem << pad;
}

template <typename T>
void matOut(vector<vector<T>>& mat) {
	for (const auto& row : mat) {
		for (const T& col : row)
			cout << col << " ";
		cout << endl;
	}
}

/******************************************************************************/
/**********************         Don't make WA !!         **********************/
/******************************************************************************/

int main()
{
	int N;
	cin >> N;
	vi t(N), v(N);
	cin >> t >> v;

	int t_all = 0;
	for (auto tt : t) t_all += tt;

	vi v_all(2 * t_all + 1, 0);
	int idx = 0, tmp = t[0];
	for (int i = 0; i < 2 * t_all + 1; i++) {
		v_all[i] = v[idx];
		if (i == 2 * tmp && idx < N - 1) {
			idx++;
			tmp += t[idx];
		}
	}

	for (int i = 1; i < 2 * t_all + 1; i++)
		if (v_all[i - 1] > v_all[i]) v_all[i - 1] = v_all[i];

	v_all[0] = v_all[2 * t_all] = 0;

	vector<float> v_add(2 * t_all + 1, 0), inv_v_add(2 * t_all + 1, 0);
	for (int i = 1; i < 2 * t_all; i++) {
		if (v_add[i - 1] < v_all[i])
			v_add[i] = v_add[i - 1] + 0.5;
		else
			v_add[i] = v_all[i];
	}

	for (int i = 2 * t_all - 1; i >= 0; i--) {
		if (inv_v_add[i + 1] < v_all[i])
			inv_v_add[i] = inv_v_add[i + 1] + 0.5;
		else
			inv_v_add[i] = v_all[i];
	}

	double ans = 0;
	for (int i = 1; i < 2 * t_all + 1; i++) {
		float height1 = min(v_add[i - 1], inv_v_add[i - 1]);
		float height2 = min(v_add[i], inv_v_add[i]);
		ans += (height1 + height2) * 0.25;
	}

	cout << setprecision(10) << ans << endl;


	return 0;
}

Measured memory_bytes: 768