Problem:
問題 H
あばれうなぎ
問題文
きつねのしえるはうなぎを食べるのが好きである．
2T+1
枚の鉄板が連続して並んでおり，順番に
-T, -T+1, ..., T
の番号が付いている．しえるはこれらの鉄板に熱を加え，生きたうなぎを焼こうとしている．うなぎを焼く手順は以下のようなものである．
まず，時刻
t=-1
のときに各鉄板にどれだけのエネルギーを加えるかを決め，実際にエネルギーを加える．各鉄板に加えるエネルギーの総和は
E
以下でなければならない．すなわち，
i
番の鉄板に加えるエネルギーを
E(i)
として，
E(i) ≥ 0, E(-T)+...+E(T) ≤ E
でなければならない．なお，エネルギーは整数でなくてもよい．
エネルギーを加えたあと，鉄板の熱さは
E(i) / C(i)
になる．ここで，
C(i)
は
i
番の鉄板の比熱である．
t = -0.5
のときにうなぎを
0
番の鉄板に載せる．
t = 0, 1, 2,..., T
のときに，うなぎは今自分がいる鉄板の熱さだけ加熱される．
t = 0.5, 1.5, 2.5,...,T-0.5
のとき，うなぎは自分の今いる鉄板にとどまるか，両隣の鉄板に移動することができる．
t = T+0.5
のときにうなぎを鉄板の上から回収する．
ところで生きたうなぎというのはとても活きがよくさらに頭も良いので，もしかすると自分にかかる熱さの総和が最小になるように動いたりするんではないかとしえるは不安になった．そうなると鉄板に適当に熱を加えただけではうなぎを十分に加熱できない恐れさえある．
そこであなたには，うなぎが常に最適に動くとして，うなぎに与えることのできる熱さの和の最大値を求めて欲しい．
入力形式
入力は以下の形式で与えられる．
T
E
C(-T)
C(-T+1)
...
C(T)
T
はうなぎを熱する時間，
E
は鉄板に与えることの出来るエネルギーの総和，
C(i)
は
i
番の鉄板の比熱である．
出力形式
1
行目にうなぎに与えられる熱さの和の最大値を出力せよ．小数点以下何桁でも出力して構わないが，相対誤差あるいは絶対誤差が
10
-6
未満になっていなければならない．
制約
1 ≤ T ≤ 10
5
1 ≤ E ≤ 10
5
1 ≤ C(i) ≤ 10
5
入力に含まれる値はすべて整数である．
入出力例
入力例 1
1 100
1 1 1
出力例 1
100.0
この場合は
0
番の鉄板にエネルギーを全て加えるのが最適である．
入力例 2
2 100
1 2 100 2 1
出力例 2
2.8301886792453
入力例 3
5 100000
99999 99999 99999 1 1000 1000 1000 1 99999 99999 99999
出力例 3
199.4680851063830
謝辞
この問題は Writer の二人がインド料理 RAJU 百万遍店とマクドナルド百万遍店において夏の暑さに辟易する中で作られた．

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 100005

int T;
double C[2*NUM+1],E;

//右側の合成プレートの比熱を求める
double calc_right(){

	double ret = C[2*T];
	int rest_time = 1;

	for(int base_loc = 2*T-1; base_loc >= T+1; base_loc--){

		ret = min(C[base_loc],(ret*rest_time+C[base_loc])/(double)(rest_time+1));
		rest_time++;
	}

	return ret;
}

//左側の合成プレートの比熱を求める
double calc_left(){

	double ret = C[0];
	int rest_time = 1;

	for(int base_loc = 1; base_loc <= T-1; base_loc++){

		ret = min(C[base_loc],(ret*rest_time+C[base_loc])/(double)(rest_time+1));
		rest_time++;
	}

	return ret;
}

int main(){

	scanf("%d %lf",&T,&E);

	for(int i = 0; i < 2*T+1; i++){
		scanf("%lf",&C[i]);
	}

	double LEFT,RIGHT;

	//左方向の合成プレートの比熱計算
	LEFT = calc_left();

	//右方向の合成プレートの比熱計算
	RIGHT = calc_right();

	double ans = E/C[T];
	double mid,another;

	mid = E/(C[T]+T*(LEFT+RIGHT));
	another = (E-mid*C[T])/(LEFT+RIGHT);

	ans = max(ans,min((T+1)*mid,mid+another));

	printf("%.10lf\n",ans);

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4744
final_rank: 7

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 100005

int T;
double C[2*NUM+1],E;

//右側の合成プレートの比熱を求める
double calc_right(){

	double ret = C[2*T];
	int rest_time = 1;

	for(int base_loc = 2*T-1; base_loc >= T+1; base_loc--){

		ret = min(C[base_loc],(ret*rest_time+C[base_loc])/(double)(rest_time+1));
		rest_time++;
	}

	return ret;
}

//左側の合成プレートの比熱を求める
double calc_left(){

	double ret = C[0];
	int rest_time = 1;

	for(int base_loc = 1; base_loc <= T-1; base_loc++){

		ret = min(C[base_loc],(ret*rest_time+C[base_loc])/(double)(rest_time+1));
		rest_time++;
	}

	return ret;
}

int main(){

	scanf("%d %lf",&T,&E);

	for(int i = 0; i < 2*T+1; i++){
		scanf("%lf",&C[i]);
	}

	double LEFT,RIGHT;

	//左方向の合成プレートの比熱計算
	LEFT = calc_left();

	//右方向の合成プレートの比熱計算
	RIGHT = calc_right();

	double ans = 0;
	double mid,another;

	mid = E/C[T];
	another = 0;
	ans = max(ans,min((T+1)*mid,mid+another));

	mid = E/(C[T]+T*(LEFT+RIGHT));
	another = (E-mid*C[T])/(LEFT+RIGHT);

	ans = max(ans,min((T+1)*mid,mid+another));

	printf("%.10lf\n",ans);

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4772
final_rank: 8

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<long long int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T+1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	assert(l<r);
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(20)<<fixed<<ans<<endl;
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 4524
final_rank: 9

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T+1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	assert(l<r);
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(20)<<fixed<<ans<<endl;
	return 0;
}
accuracy: 0.4523809523809524
time_ms: 40
memory_kb: 3672
final_rank: 15

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T+1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(20)<<fixed<<ans<<endl;
	return 0;
}
accuracy: 0.4523809523809524
time_ms: 40
memory_kb: 3668
final_rank: 14

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T-1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(20)<<fixed<<ans<<endl;
	return 0;
}
accuracy: 0.4523809523809524
time_ms: 40
memory_kb: 3656
final_rank: 13

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T-1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(10)<<fixed<<ans<<endl;
	return 0;
}
accuracy: 0.4523809523809524
time_ms: 40
memory_kb: 3552
final_rank: 12

code_snippet: #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>

//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else

//#endif

using namespace std;


typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x)  cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x) 
#define debug(x) 
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x

#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;

void mainmain(){
	int T,E;
	cin>>T>>E;
	vector<double> v1(T),v2(T);
	rep(i,T){
		cin>>v1[T-1-i];
	}
	double b;
	cin>>b;
	rep(i,T){
		cin>>v2[i];
	}
	double a=v1[T-1];
	double c=v2[T-1];
	for(int i=T-2;i>=0;i--){
		int s=T-i;
		if(v1[i]>=a){
			a=(v1[i]+a*(s-1))/(s);
		}
		else{
			a=v1[i];
		}
		if(v2[i]>=c){
			c=(v2[i]+c*(s-1))/(s);
		}
		else{
			c=v2[i];
		}
	}
	double ans1=max(E/b,(double)E*(T+1)/(T*(a+c)+b));
	cout<<LDcout(ans1,10)<<endl;
}


signed main() {
	ios_base::sync_with_stdio(false);
  	// cout<<fixed<<setprecision(10);
    mainmain();
}
accuracy: 1
time_ms: 40
memory_kb: 2844
final_rank: 5

code_snippet: #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>

//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else

//#endif

using namespace std;


typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x)  cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x) 
#define debug(x) 
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x

#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;

void mainmain(){
	int T,E;
	cin>>T>>E;
	vector<double> v1(T),v2(T);
	rep(i,T){
		cin>>v1[T-1-i];
	}
	double b;
	cin>>b;
	rep(i,T){
		cin>>v2[i];
	}
	double a=v1[T-1];
	double c=v2[T-1];
	for(int i=T-2;i>=0;i--){
		int s=T-i;
		// cout<<v1[i]<<endl;
		// cout<<s<<endl;
		if(v1[i]>=a){
			a=(v1[i]+a*(s-1))/(s);
		}
		else{
			a=v1[i];
		}
		if(v2[i]>=c){
			c=(v2[i]+c*(s-1))/(s);
		}
		else{
			c=v2[i];
		}
	}
	// cout<<a<<" "<<b<<" "<<c<<endl;
	double l=0,r=E;
	while(r-l>EPS){
		double mid1=l+(r-l)/3;
		double mid2=l+(r-l)*2/3;
		double h1=(E-(a+c)*mid1)/b;
		double h2=(E-(a+c)*mid2)/b;
		double ans1=min(mid1+h1,T*h1);
		double ans2=min(mid2+h2,T*h2);
		if(ans1<ans2){
			l=mid1;
		}
		else{
			r=mid2;
		}
	}
	// cout<<a<<" "<<c<<endl;
	// cout<<E*(T+1)<<endl;
	double ans1=max(E/b,(double)E*(T+1)/(T*(a+c)+b));
	// cout<<l+h1<<" "<<T*h1<<endl;
	cout<<ans1<<endl;
}


signed main() {
	ios_base::sync_with_stdio(false);
  	cout<<fixed<<setprecision(10);
    mainmain();
}
accuracy: 1
time_ms: 40
memory_kb: 2844
final_rank: 5

code_snippet: #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>

//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else

//#endif

using namespace std;


typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x)  cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x) 
#define debug(x) 
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x

#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;

void mainmain(){
	int T,E;
	cin>>T>>E;
	vector<double> v1(T),v2(T);
	rep(i,T){
		cin>>v1[T-1-i];
	}
	double b;
	cin>>b;
	rep(i,T){
		cin>>v2[i];
	}
	double a=v1[T-1];
	double c=v2[T-1];
	for(int i=T-2;i>=0;i--){
		int s=T-i;
		// cout<<v1[i]<<endl;
		// cout<<s<<endl;
		if(v1[i]>=a){
			a=(v1[i]+a*(s-1))/(s);
		}
		else{
			a=v1[i];
		}
		if(v2[i]>=c){
			c=(v2[i]+c*(s-1))/(s);
		}
		else{
			c=v2[i];
		}
	}
	// cout<<a<<" "<<b<<" "<<c<<endl;
	double l=0,r=E;
	while(r-l>EPS){
		double mid1=l+(r-l)/3;
		double mid2=l+(r-l)*2/3;
		double h1=(E-(a+c)*mid1)/b;
		double h2=(E-(a+c)*mid2)/b;
		double ans1=min(mid1+h1,T*h1);
		double ans2=min(mid2+h2,T*h2);
		if(ans1<ans2){
			l=mid1;
		}
		else{
			r=mid2;
		}
	}
	// cout<<a<<" "<<c<<endl;
	double ans1=max(E/b,E*(T+1)/(T*(a+c)+b));
	// cout<<l+h1<<" "<<T*h1<<endl;
	cout<<ans1<<endl;
}


signed main() {
	ios_base::sync_with_stdio(false);
  	cout<<fixed<<setprecision(10);
    mainmain();
}
accuracy: 0.47619047619047616
time_ms: 40
memory_kb: 2844
final_rank: 11

code_snippet: #include <cstdio>

using namespace std;

int main()
{
	for(int t,e;~scanf("%d%d",&t,&e);){
		double c[2*t+1];
		for(int i=0;i<2*t+1;i++)
			scanf("%lf",c+i);
		for(int s=2;s<=t;s++){
			if(c[t+(t-s+1)]>c[t+(t-s+2)])
				c[t+(t-s+1)]=(c[t+(t-s+1)]+(s-1)*c[t+(t-s+2)])/s;
			if(c[t-(t-s+1)]>c[t-(t-s+2)])
				c[t-(t-s+1)]=(c[t-(t-s+1)]+(s-1)*c[t-(t-s+2)])/s;
		}
		if(c[t]>c[t-1]+c[t+1])
			c[t]=(c[t]+t*(c[t-1]+c[t+1]))/(t+1);
		printf("%.13f\n",e/c[t]);
	}
}
accuracy: 1
time_ms: 40
memory_kb: 2640
final_rank: 4

code_snippet: #include<cstdio>
#include<algorithm>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;

int T,E;
double *C,C_buf[200001];

double merge(){
	double res=C[T];
	for(int i=T-1;i>=1;i--){
		// プレート i と i+1 をマージし、それを新たにプレート i と思う
		// そうすると、新たなプレート i+1 にはエネルギーをかけないと考えていい
		res=min(C[i],(C[i]+(T-i)*res)/(T-i+1));
		// min の第 1 項は ( マージする前の ) プレート i+1 にエネルギーをかけないケース (?)
		// min の第 2 項は ( マージする前の ) プレート i+1 にエネルギーをかけるケース
	}
	return res;
}

int main(){
	scanf("%d%d",&T,&E);
	C=C_buf+100000;
	for(int i=-T;i<=T;i++) scanf("%lf",C+i);

	double C0=C[0];
	double Cr=merge(); // 右 T 枚のプレートをマージしてできたプレートの比熱
	reverse(C-T,C+T+1);
	double Cl=merge(); // 左 T 枚のプレートをマージしてできたプレートの比熱

	// これで 3 枚のプレート -1, 0, 1 の問題になった
	// 解は
	// - プレート 0 で T+1 回熱せられる
	// - プレート 0 で 1 回、プレート  1 で 1 回熱せられる
	// - プレート 0 で 1 回、プレート -1 で 1 回熱せられる
	// のいずれか

	// プレートにかける熱をそれぞれ Hl, H0, Hr とする
	// 制約 Cl*Hl+C0*H0+Cr*Hr = E のもと、min{(T+1)*H0, H0+Hl, H0+Hr} を最大化する問題になる
	// Hl = Hr とするのがいいことは直感的にわかるので、
	// 制約 C0*H0+(Cl+Cr)*Hl = E のもと、min{(T+1)*H0, H0+Hl} を最大化すればいい
	double ans=0,H0,Hl;
	H0=E/C0;             Hl=(E-C0*H0)/(Cl+Cr); ans=max(ans,min((T+1)*H0,H0+Hl));
	H0=E/(C0+T*(Cl+Cr)); Hl=(E-C0*H0)/(Cl+Cr); ans=max(ans,min((T+1)*H0,H0+Hl));
	printf("%.9f\n",ans);

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 2220
final_rank: 2

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>
#define REP(i,n) for(int i=0; i<(int)(n); i++)

inline int getInt(){ int s; scanf("%d", &s); return s; }

using namespace std;

double buff[200200];
double *c;
int t;
int e;


int main(){
  t = getInt();
  e = getInt();

  REP(i, 2 * t + 1) buff[i] = (double)getInt();
  c = &buff[t];

  for(int s = 2; s <= t; s++){
    {
      // merge to left
      double alpha = c[t - s + 1];
      double beta  = c[t - s + 2];
      if(alpha > beta){
	c[t - s + 1] = (alpha + beta * (s - 1)) / s;
      }
    }
    {
      // merge to right
      double alpha = c[-(t - s + 1)];
      double beta  = c[-(t - s + 2)];
      if(alpha > beta){
	c[-(t - s + 1)] = (alpha + beta * (s - 1)) / s;
      }
    }
  }
  
  double alpha = c[-1];
  double beta  = c[0];
  double ganma = c[1];

  double ans;

  double h1 = e / (alpha + ganma + beta / t);
  double h2 = (e - (alpha + ganma) * h1) / beta;
  ans = h1 + h2;

  ans = max(ans, e / beta);

  printf("%.7f\n", ans);

  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 2304
final_rank: 3

code_snippet: #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;

int main()
{
    int t, e;
    cin >> t >> e;

    vector<double> c(2*t+1);
    for(int i=0; i<2*t+1; ++i)
        cin >> c[i];

    // ツ熱ツつウT+1ツつセツつッツ嘉熱ツつキツづゥツつスツづ淞づ可必ツ要ツづ按催渉ャツエツネツδ仰ギツー
    double minLeft = 0.0;
    double minRight = 0.0;
    for(int i=0; i<t; ++i){
        minLeft = min(minLeft + c[i], c[i] * (i+1));
        minRight = min(minRight + c[2*t-i], c[2*t-i] * (i+1));
    }
    double minEnergy = min(minLeft + minRight + c[t], c[t] * (t+1));

    double ret = e / minEnergy * (t+1);
    printf("%.10f\n", ret);

    return 0;
}
accuracy: 1
time_ms: 130
memory_kb: 2484
final_rank: 10

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n;
double E;
double plate[300000];

inline double Get(int index) {
  return plate[index + n];
}

inline double Merge(double x, double y, int w) {
  return min(y, (w * x + y) / (w + 1));
}

double MergeAll(int dir) {
  double left = Get(-dir * n);
  int w = 1;
  int index = -dir * n + dir;
  while (index != 0) {
    left = Merge(left, Get(index), w);
    //cout << index << " " << left << " " << w << endl;
    assert(left >= -EPS);
    w++;
    index += dir;
  }
  return left;
}

int main() {
  while (scanf("%d %lf", &n, &E) > 0) {
    REP(i, 2 * n + 1) {
      scanf("%lf", &plate[i]);
    }
    double left = MergeAll(1);
    double right = MergeAll(-1);
    double ans = max(E / Get(0), E * (n + 1) / (n * (left + right) + Get(0)));
    printf("%.8f\n", ans);
  }
}
accuracy: 1
time_ms: 50
memory_kb: 0
final_rank: 1