text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int M = 200005;
int A[M];
double B[M];
int n;
double check(double x) {
for (int i = 1, i_END_ = n + 1; i < i_END_; ++i) B[i] = A[i] - x;
double mx = -1e60, mi = 1e60, s1 = 0, s2 = 0;
for (int i = 1, i_END_ = n + 1; i < i_END_; ++i) {
s1 += B[i];
mx = max(s1, mx);
if (s1 < 0) s1 = 0;
s2 += B[i];
mi = min(mi, s2);
if (s2 > 0) s2 = 0;
}
return max(mx, -mi);
}
int main() {
scanf("%d", &n);
for (int i = 1, i_END_ = n + 1; i < i_END_; ++i) scanf("%d", &A[i]);
double L = -10000, R = 10000, res = -10001;
double ans = 1e60;
for (int i = 0, i_END_ = 100; i < i_END_; ++i) {
double del = (R - L) / 3;
double m1 = L + del, m2 = R - del;
double r1 = check(m1), r2 = check(m2);
ans = min(ans, min(r1, r2));
if (r2 < r1)
L = m1;
else
R = m2;
}
printf("%.12f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const double inf = 0x3f3f3f3f;
int n;
double a[maxn], mmin, mmax, tmin, tmax;
double weakness(double pos) {
mmin = 0;
mmax = 0;
tmin = 0;
tmax = 0;
for (int i = 0; i < n; i++) {
tmin += a[i] - pos;
if (tmin > 0) tmin = 0;
tmax += a[i] - pos;
if (tmax < 0) tmax = 0;
mmin = min(mmin, tmin);
mmax = max(mmax, tmax);
}
return max(-mmin, mmax);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf", &a[i]);
int cnt = 0;
double left = -10000, right = 10000;
while (cnt++ < 300) {
double mid = (left + right) / 2;
double mmid = (mid + right) / 2;
if (weakness(mid) < weakness(mmid))
right = mmid;
else
left = mid;
}
printf("%.9lf\n", weakness(left));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double cal(int n, int *a, double x) {
double ret = 0, t1 = 0, t2 = 0;
for (int i = 0; i < n; i++) {
t1 += a[i] - x;
t2 += a[i] - x;
t1 = max(0., t1);
t2 = min(0., t2);
ret = max(ret, t1);
ret = max(ret, -t2);
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
static int a[200000];
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
double l = -10001, r = 10001, ans;
for (int t = 0; t < 100; t++) {
double d1 = (2 * l + r) / 3, d2 = (l + 2 * r) / 3;
double e1 = cal(n, a, d1), e2 = cal(n, a, d2);
if (e1 <= e2) {
r = d2;
ans = e1;
} else {
l = d1;
ans = e2;
}
}
printf("%.9lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-12;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double Max, Min, now;
double l = -1e4, r = 1e4;
while (r - l > eps) {
double m = (l + r) / 2;
now = 0;
Max = -1e9;
for (int i = 0; i < n; i++) {
now += a[i] - m;
if (now > Max) Max = now;
if (now < 0) now = 0;
}
now = 0;
Min = 1e9;
for (int i = 0; i < n; i++) {
now += a[i] - m;
if (now < Min) Min = now;
if (now > 0) now = 0;
}
if (Max + Min > 0)
l = m;
else
r = m;
}
printf("%.10f", Max);
return 0;
}
|
#include <bits/stdc++.h>
const double eps = 1e-10;
const int MaxN = 200005;
double a[MaxN];
int n;
double sol(double x) {
double s = 0, mx = 0, mn = 0, res = -1e20;
for (int i = 0; i < n; i++) {
s += a[i] - x;
res = std::max(res, fabs(s - mn));
res = std::max(res, fabs(s - mx));
mx = std::max(mx, s);
mn = std::min(mn, s);
}
return res;
}
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
}
double l = -1e20, r = 1e20, mid1, mid2, res1, res2;
for (int i = 0; i < 200; i++) {
mid1 = (2 * l + r) / 3.0;
mid2 = (l + 2 * r) / 3.0;
res1 = sol(mid1);
res2 = sol(mid2);
if (res1 < res2 + eps) {
r = mid2;
} else {
l = mid1;
}
}
printf("%.12f\n", sol((l + r) / 2.0));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[200005];
int n, k;
double cal(double x) {
double maxx = 0, minn = 0;
for (int i = 1; i <= n; i++) {
double val = -x * i + t[i];
maxx = max(maxx, val);
minn = min(minn, val);
}
return maxx - minn;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
t[0] = 0;
for (int i = 1; i <= n; i++) cin >> k, t[i] = t[i - 1] + k;
double l = -30000, h = 30000;
int cc = 0;
for (int i = 1; i <= 100; i++) {
cc++;
double r1 = l + (h - l) / 3;
double r2 = l + (h - l) * 2 / 3;
double R1 = cal(r1);
double R2 = cal(r2);
if (R1 < R2 + 1e-8)
h = r2;
else
l = r1;
}
printf("%.9lf", cal((l + h) / 2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const int INF = 10000 + 10;
const double eps = 1e-11;
int n, k = 100;
double a[maxn], dp1[maxn], dp2[maxn];
double get_max(double x, double y) { return x > y ? x : y; }
double get_min(double x, double y) { return x < y ? x : y; }
double f(double x) {
int i;
double max = 0, b[maxn];
for (i = 0; i < n; i++) b[i] = a[i] - x;
dp1[0] = b[0];
for (i = 1; i < n; i++) dp1[i] = get_max(dp1[i - 1] + b[i], b[i]);
dp2[0] = b[0];
for (i = 1; i < n; i++) dp2[i] = get_min(dp2[i - 1] + b[i], b[i]);
for (i = 0; i < n; i++) {
max = get_max(max, abs(dp1[i]));
max = get_max(max, abs(dp2[i]));
}
return max;
}
double divide(double &l, double &r) {
double mid, mmid, fmid, fmmid;
if (r - l < eps) return (l + r) / 2;
mid = (r + 2 * l) / 3;
mmid = (l + 2 * r) / 3;
fmid = f(mid);
fmmid = f(mmid);
if (fmid <= fmmid)
r = mmid;
else if (fmid > fmmid)
l = mid;
return divide(l, r);
}
int main() {
int i;
double ans, max = -INF, min = INF;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lf", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
if (a[i] < min) min = a[i];
}
while (k--) {
divide(min, max);
}
ans = divide(min, max);
printf("%.6lf\n", f(ans));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
double f(const vector<int> &a, double x) {
double s = 0.0, mins = 0, maxs = 0;
for (int i = 0; i < (int)(a.size()); ++i) {
s += a[i] + x;
uin(mins, s);
uax(maxs, s);
}
return maxs - mins;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < (int)(N); ++i) cin >> a[i];
double l = -1e9, r = 1e9;
int A = 11, B = 10;
for (int its = 0; its < (int)(100); ++its) {
double m1 = (A * l + B * r) / (A + B);
double m2 = (B * l + A * r) / (A + B);
double f1 = f(a, m1), f2 = f(a, m2);
if (f1 < f2)
r = m2;
else
l = m1;
}
cout << f(a, l) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n;
int a[N];
double b[N], sum[N];
double cal(double x) {
sum[0] = 0;
for (int i = 1; i <= n; i++) b[i] = 1.0 * a[i] - x;
double mneg, mpos;
mneg = mpos = 0;
double gtmax = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + b[i];
gtmax = max(gtmax, abs(b[i]));
gtmax = max(gtmax, max(abs(sum[i] - mneg), abs(sum[i] - mpos)));
mneg = min(mneg, sum[i]);
mpos = max(mpos, sum[i]);
}
return gtmax;
}
bool cp(double x, double y) {
double t = abs(x - y);
return (t > 0.000000000001);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
double L = -1000001;
double R = 1000001;
double ML = (L + L + R) / 3;
double MR = (L + R + R) / 3;
while (cp(L, ML) && cp(ML, MR) && cp(MR, R)) {
double x = cal(ML);
double y = cal(MR);
if (x > y)
L = ML;
else
R = MR;
ML = (L + L + R) / 3;
MR = (L + R + R) / 3;
}
double ans = cal((L + R) / 2);
printf("%0.7f", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double b[300001], sum[300001];
int a[300001];
int n;
double check(double x) {
for (int i = 1; i <= n; i++) b[i] = a[i] * 1.0 - x;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + b[i];
double Min = 0.0, Max = 0.0;
double ans = 0.0;
for (int i = 1; i <= n; i++) {
ans = max(ans, fabs(sum[i] - Min));
ans = max(ans, fabs(sum[i] - Max));
Min = min(Min, sum[i]);
Max = max(Max, sum[i]);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
double l = -999999.0, r = 999999.0;
double ans = 9999999999999.0;
bool flag = false;
for (int i = 1; i <= 200; i++) {
double mid1 = l + (r - l) / 3.0, mid2 = r - (r - l) / 3.0;
double tmpx = check(mid1), tmpy = check(mid2);
if (tmpx > tmpy)
l = mid1;
else
r = mid2;
if (flag == false) {
flag = true;
ans = tmpx;
} else
ans = min(ans, tmpx);
ans = min(ans, tmpy);
}
ans = min(ans, check(l));
printf("%.9f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 100;
int n, k, x;
int a[maxN];
double s[maxN];
double tim() {
double res = s[1], sum = 0;
for (int i = 1; i <= n; i++) {
sum += s[i];
res = max(res, sum);
if (sum < 0) sum = 0;
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%i", &a[i]);
double res = 1e18;
double l = 1e9, r = -1e9;
for (int i = 1; i <= n; i++)
l = min(l, double(a[i])), r = max(r, double(a[i]));
int dem = 100;
while (dem--) {
double mid = (l + r) / 2;
for (int i = 1; i <= n; i++) s[i] = double(a[i]) - mid;
double s1 = tim();
for (int i = 1; i <= n; i++) s[i] = -s[i];
double s2 = tim();
res = min(max(abs(s1), abs(s2)), res);
if (abs(s1) > abs(s2))
l = mid;
else
r = mid;
}
printf("%.9f", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 256;
const char nxt = '\n';
const double eps = 1e-12;
inline bool Pal(const string& s) {
return equal(s.begin(), s.end(), s.rbegin());
}
inline int readint() {
bool neg = false;
int ret = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') {
neg = true;
break;
}
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (!neg) ret = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
ret = ret * 10 + ch - '0';
}
return neg ? -ret : ret;
}
int n;
double arr[MAXN];
double ans;
inline double calc() {
double ans = 0;
double sum = 0;
for (int i = 1; i <= n; ++i) {
sum += arr[i];
if (sum > ans) ans = sum;
if (sum < 0) sum = 0;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(10) << fixed;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
double l = -1000000.0000, r = 1000000.00000;
for (int i = 1; i <= 300; ++i) {
double mid = (l + r) / 2.000;
for (int j = 1; j <= n; ++j) arr[j] -= mid;
double cur1 = calc();
for (int j = 1; j <= n; ++j) arr[j] = -arr[j];
double cur2 = calc();
for (int j = 1; j <= n; ++j) arr[j] = -arr[j], arr[j] += mid;
if (cur1 >= cur2) {
l = mid;
ans = cur1;
} else
r = mid;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
double a[200010], sum[200010];
double cal(double X) {
double hsgs = 0.0, Mn = 0.0, Mx = 0.0;
for (int i = 1; i <= N; i++) {
sum[i] = sum[i - 1] + a[i] - X;
hsgs = max(max(fabs(sum[i] - Mn), fabs(sum[i] - Mx)), hsgs);
Mn = min(Mn, sum[i]);
Mx = max(Mx, sum[i]);
}
return hsgs;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%lf", &a[i]);
double l = -1e9, r = 1e9;
for (int i = 1; i <= 500; i++)
if (cal((2 * l + r) / 3) < cal((l + 2 * r) / 3))
r = (l + 2 * r) / 3;
else
l = (2 * l + r) / 3;
printf("%.15lf", cal(l));
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200010], l, r, ml, mr;
void nhap() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
double func(double x) {
double ma = 0, mi = 0, sum = 0;
for (int i = 1; i <= n; ++i) {
sum += a[i] - x;
ma = max(ma, sum);
mi = min(mi, sum);
}
return abs(ma - mi);
}
int main() {
nhap();
l = -20000, r = 20000;
for (int i = 1; i <= 100; ++i) {
ml = (l + l + r) / 3;
mr = (r + r + l) / 3;
if (func(ml) > func(mr))
l = ml;
else
r = mr;
}
printf("%.10f", func(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[200010], sum, mx, mn;
int n, x;
char c;
bool b;
double f(double x) {
sum = 0, mx = 0, mn = 0;
for (int i = 0; i < n; i++) {
sum += a[i] - x;
if (mx < sum) mx = sum;
if (mn > sum) mn = sum;
}
return (mx - mn);
}
int qin() {
b = false, x = 0;
c = getchar();
if (c == '-') {
b = true;
c = '0';
}
while (c != ' ') {
x = x * 10 + (c - '0');
c = getchar();
}
if (b) return -x;
return x;
}
int qin2() {
b = false, x = 0;
c = getchar();
if (c == '-') {
b = true;
c = '0';
} else
x = c - '0';
while ((c = getchar()) != EOF && c >= '0' && c <= '9') x = x * 10 + (c - '0');
if (b) return -x;
return x;
}
int main() {
n = qin2();
for (int i = 0; i < n - 1; i++) a[i] = qin();
a[n - 1] = qin2();
double l = -10001, r = 10001, ml, mr, z1, z2;
int x = 0;
while (r - l >= 0.00000000001) {
ml = (l + r) / 2.0;
mr = (ml + r) / 2.0;
z1 = f(mr), z2 = f(ml);
if (z1 < z2)
l = ml;
else
r = mr;
x++;
}
l = (l + r) / 2.0;
printf("%.15lf", f(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto f = [&](double x) {
double Min = 0, Max = 0, sm = 0;
for (int i = 0; i < n; i++) {
sm += a[i] - x;
Min = min(Min, sm);
Max = max(Max, sm);
}
return abs(Max - Min);
};
double low = -1e6, high = 1e6;
for (int i = 0; i < 200; i++) {
double m1 = (2 * low + high) / 3;
double m2 = (low + 2 * high) / 3;
if (f(m1) < f(m2)) {
high = m2;
} else {
low = m1;
}
}
cout << setprecision(6) << fixed;
cout << f(low) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long double> cum, cumt;
long double weakness() {
long double mx = 0, mxc = 0, mn = INT_MAX, mnc = INT_MAX;
mx = mxc = cum[0];
for (int i = 1; i < n; i++) {
mxc = max(cum[i], mxc + cum[i]);
mx = max(mx, mxc);
}
mn = mnc = cum[0];
for (int i = 1; i < n; i++) {
mnc = min(cum[i], mnc + cum[i]);
mn = min(mn, mnc);
}
return max(abs(mx), abs(mn));
}
long double calc(long double x) {
for (double i = 0; i < n; i++) cum[i] = cumt[i] - x;
return weakness();
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
cum.resize(n), cumt.resize(n);
for (int i = 0; i < n; i++) cin >> cum[i];
cumt = cum;
long double a = -10000, d = 10000, b = (2 * a + d) / 3, c = (a + 2 * d) / 3;
while (c - b > 0.000000000001) {
if (calc(b) > calc(c))
a = b;
else
d = c;
b = (2 * a + d) / 3, c = (a + 2 * d) / 3;
}
cout << fixed << setprecision(7) << calc(b) << endl;
cin.ignore(), cin.get();
}
|
#include <bits/stdc++.h>
using namespace std;
int N, a[200000 + 3];
double prefix[200000 + 3];
pair<double, double> getWeakness(double x) {
prefix[0] = 0;
for (int i = 1; i <= N; i++) prefix[i] = prefix[i - 1] + (a[i] - x);
double minPrefix = 0, maxPrefix = 0;
double maxF = -1e10, maxG = -1e10;
for (int j = 1; j <= N; j++) {
double F = prefix[j] - minPrefix;
double G = -prefix[j] + maxPrefix;
maxF = max(maxF, F);
maxG = max(maxG, G);
minPrefix = min(minPrefix, prefix[j]);
maxPrefix = max(maxPrefix, prefix[j]);
}
return {maxF, maxG};
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
double lo = -10000, hi = 10000, mid;
for (int rep = 1; rep <= 100; rep++) {
mid = (lo + hi) / 2.0;
auto weakness = getWeakness(mid);
if (weakness.first > weakness.second)
lo = mid;
else
hi = mid;
}
auto weakness = getWeakness(lo);
printf("%.10lf\n", max(weakness.first, weakness.second));
}
|
#include <bits/stdc++.h>
using namespace std;
double a[222222], b[222222];
int n;
double f(double x) {
for (int i = 0; i < n; i++) b[i] = a[i] - x;
double MAX = -0x3f3f3f3f, ans = 0;
for (int i = 0; i < n; i++) {
ans += b[i];
MAX = max(ans, MAX);
if (ans < 0) ans = 0;
}
double MIN = 0x3f3f3f3f;
ans = 0;
for (int i = 0; i < n; i++) {
ans += b[i];
MIN = min(ans, MIN);
if (ans > 0) ans = 0;
}
return max(fabs(MIN), fabs(MAX));
}
int main() {
scanf("%d", &n);
double l = 0x3f3f3f3f, r = -0x3f3f3f3f;
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
l = min(a[i], l);
r = max(a[i], r);
}
while (1) {
if (r - l <= 1e-11) break;
double mid = (l + r) / 2;
double mmid = (mid + r) / 2;
if (f(mid) <= f(mmid))
r = mmid;
else
l = mid;
}
double goal = (l + r) / 2;
printf("%.15f\n", f(goal));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200000 + 10], ans = -0x7fffffff;
double l[200000 + 10];
void Read(int &x) {
char c;
bool f = 0;
while (c = getchar(), c != EOF) {
if (c == '-') f = 1;
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
if (f) x = -x;
ungetc(c, stdin);
return;
}
}
}
double get_poor(double x) {
int i;
double sum = 0, ret = 0;
for (i = 1; i <= n; i++) l[i] = a[i] - x;
for (i = 1; i <= n; i++) {
sum += l[i];
if (sum < 0) sum = 0;
ret = max(sum, ret);
l[i] = -l[i];
}
sum = 0;
for (i = 1; i <= n; i++) {
sum += l[i];
if (sum < 0) sum = 0;
ret = max(sum, ret);
}
return ret;
}
int main() {
Read(n);
int i;
for (i = 1; i <= n; i++) Read(a[i]);
double l = -1e4, r = 1e4, m1, m2, v1, v2;
i = 100;
while (i--) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
v1 = get_poor(m1);
v2 = get_poor(m2);
if (v1 > v2)
l = m1;
else
r = m2;
}
printf("%.15lf\n", get_poor(l));
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647, MOD = 1000 * 1000 * 1000 + 7;
const double eps = 1e-8;
void Error(string err) {
cout << err;
cerr << "_" << err << "_";
exit(0);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
const int sz = 222 * 1000;
int arr[sz], arr2[sz];
double sum[sz];
int n;
double f(double x) {
double ret = 0;
double sm = 0;
for (int i = 0; i < (n); i++) {
if (sm + arr[i] - x > arr[i] - x)
sm += arr[i] - x;
else
sm = arr[i] - x;
ret = max(ret, abs(sm));
}
sm = 0;
for (int i = 0; i < (n); i++) {
if (sm + arr[i] - x < arr[i] - x)
sm += arr[i] - x;
else
sm = arr[i] - x;
ret = max(ret, abs(sm));
}
return ret;
}
int main() {
cin >> n;
for (int i = 0; i < (n); i++) cin >> arr[i];
sum[0] = arr[0];
for (int i = 1; i <= (n - 1); i++) sum[i] = sum[i - 1] + arr[i];
for (int i = 0; i < (n); i++) arr2[i] = arr[i];
sort(arr2, arr2 + n);
double a = arr2[n / 2];
double wa = f(a);
double inc = (arr2[n - 1] - arr2[0]);
while (true) {
wa = f(a);
double nwai = f(a + inc), nwad = f(a - inc);
if (wa > nwai && wa < nwad)
a += inc;
else if (wa > nwad && wa < nwai)
a -= inc;
else
inc /= 2;
double x = wa - nwai;
double y = wa - nwad;
double z = nwai - nwad;
x = abs(x) + abs(y) + abs(z);
if (x < 1e-9) break;
}
cout.setf(ios::fixed);
cout.precision(8);
cout << wa << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double e = exp(1.0);
const double INF = 1e9;
const double eps = 1e-11;
double maxX = -INF;
double minX = INF;
const int N = 200000 + 10;
double a[N];
double fx(double v, int n) {
double tmp = a[0] - v;
double neg_tmp = a[0] - v;
bool flag = false;
if (a[0] < v) flag = true;
for (int i = 1; i < n; i++) {
if (a[i] < v) flag = true;
tmp += a[i] - v;
if (tmp < a[i] - v) tmp = a[i] - v;
neg_tmp = max(tmp, neg_tmp);
}
if (flag) {
maxX = v - a[0];
tmp = v - a[0];
for (int i = 1; i < n; i++) {
tmp += v - a[i];
if (tmp < v - a[i]) tmp = v - a[i];
maxX = max(tmp, maxX);
}
}
return max(neg_tmp, maxX);
}
int main() {
int n;
cin >> n;
double xi = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
maxX = max(a[i], maxX);
maxX = max(-a[i], maxX);
minX = min(a[i], minX);
}
double L = -INF;
double R = INF;
while (L + eps < R) {
double mid_L = (2 * L + R) / 3;
double mid_R = (L + 2 * R) / 3;
double res_L = fx(mid_L, n);
double res_R = fx(mid_R, n);
if (res_L > res_R)
L = mid_L;
else
R = mid_R;
}
double answer = (L + R) / 2;
cout << fixed << setprecision(7) << fx(answer, n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 4;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
int n;
int a[N];
double F[N];
double f(double x) {
F[0] = 0;
double mn = 0, mx = 0;
double ans = 0;
for (int i = 1; i <= n; i++) {
F[i] = F[i - 1] + a[i] - x;
ans = max(ans, max(abs(F[i] - mn), abs(F[i] - mx)));
mn = min(mn, F[i]);
mx = max(mx, F[i]);
}
return ans;
}
int main() {
cin >> n;
for (int i = (int)1; i < (int)n + 1; i++) scanf("%d", a + i);
double lo = -10000, hi = 10000, g, res;
for (int t = (int)0; t < (int)100; t++) {
double g1 = (2 * lo + hi) / 3;
double g2 = (lo + 2 * hi) / 3;
if (f(g1) < f(g2))
hi = g2;
else
lo = g1;
}
printf("%.9lf", f(lo));
}
|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 0x7FFFFFFF;
long long INFF = 0x7FFFFFFFFFFFFFFF;
double PI = acos(-1.0);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
inline void scanf(int &d1) { scanf("%d", &d1); }
inline void scanf(int &d1, int &d2) { scanf("%d%d", &d1, &d2); }
inline void scanf(int &d1, int &d2, int &d3) { scanf("%d%d%d", &d1, &d2, &d3); }
inline void scanf(long long &d1) { scanf("%I64d", &d1); }
inline void scanf(long long &d1, long long &d2) {
scanf("%I64d%I64d", &d1, &d2);
}
inline void scanf(long long &d1, long long &d2, long long &d3) {
scanf("%I64d%I64d%I64d", &d1, &d2, &d3);
}
inline void scanf(char *temp) { scanf("%s", temp); }
inline void printf(int d1) { printf("%d\n", d1); }
inline void printf(int d1, int d2) { printf("%d %d\n", d1, d2); }
inline void printf(double f1) { printf("%.17g\n", f1); }
inline void printf(long long l1) { printf("%I64d\n", l1); }
inline void printf(long long l1, long long l2) {
printf("%I64d %I64d\n", l1, l2);
}
inline string tostring(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline void toupperstring(string &s) {
for (int(i) = (0); (i) < ((int)s.size()); ++(i)) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] = s[i] - 'a' + 'A';
}
}
}
inline void tolowerstring(string &s) {
for (int(i) = (0); (i) < ((int)s.size()); ++(i)) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] - 'A' + 'a';
}
}
}
inline int toint(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline void gopen(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
inline void gcase(int id) { printf("Case #%d:", id); }
template <typename T1, typename T2, typename T>
inline typename T::iterator findorinsert(T &m, const T1 &t1, const T2 &t2) {
typename T::iterator iter = m.find(t1);
if (iter == m.end()) {
m.insert(make_pair(t1, t2));
return m.find(t1);
} else {
return iter;
}
}
template <typename T>
inline T gcd(T u, T v) {
while (v != 0) {
T r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T, int n>
struct Vector {
T data[n];
void read() {
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> data[i];
}
}
inline T operator*(const Vector<T, n> &v) const {
T res = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
res += data[i] * v[i];
}
return res;
}
inline bool operator<(const Vector<T, n> &v) const {
for (int(i) = (0); (i) < (n); ++(i)) {
if (data[i] != v[i]) {
return data[i] < v[i];
}
}
return false;
}
inline bool operator==(const Vector<T, n> &v) const {
for (int(i) = (0); (i) < (n); ++(i)) {
if (data[i] != v[i]) {
return false;
}
}
return true;
}
inline T &operator[](int id) { return data[id]; }
inline T operator[](int id) const { return data[id]; }
inline int size() const { return n; }
};
template <typename T>
inline Vector<T, 2> make_vector(const T &t1, const T &t2) {
Vector<T, 2> res = {t1, t2};
return res;
}
template <typename T, int n>
struct Matrix {
Vector<T, n> data[n];
inline Vector<T, n> operator*(const Vector<T, n> &v) const {
Vector<T, n> res;
for (int(i) = (0); (i) < (n); ++(i)) {
res[i] = data[i] * v;
}
return res;
}
inline Matrix<T, n> operator*(const Matrix<T, n> &m) const {
Matrix<T, n> res;
for (int(i) = (0); (i) < (n); ++(i)) {
Vector<T, n> temp;
for (int(j) = (0); (j) < (n); ++(j)) {
temp[j] = m[j][i];
}
for (int(j) = (0); (j) < (n); ++(j)) {
res[j][i] = data[j] * temp;
}
}
return res;
}
static inline Matrix<T, n> identity() {
Matrix<T, n> res;
for (int(i) = (0); (i) < (n); ++(i)) {
memset(res[i].data, 0, sizeof(T) * n);
}
for (int(i) = (0); (i) < (n); ++(i)) {
res[i][i] = 1;
}
return res;
}
Vector<T, n> &operator[](int id) { return data[id]; }
Vector<T, n> operator[](int id) const { return data[id]; }
int size() const { return n; }
};
template <typename T, int n>
class BIT {
public:
BIT(int size = n) {
memset(bit, 0, sizeof(bit));
this->size = size;
}
BIT(T *data, int size = n) {
this->size = size;
for (int i = 1; i <= size; i++) {
bit[i] = data[i - 1];
for (int j = i - 1; j > i - lowbit(i); j--) {
bit[i] += bit[j];
}
}
}
void edit(int i, T delta) {
for (int j = i + 1; j <= size; j += lowbit(j)) {
bit[j] += delta;
}
}
T sum(int k) {
T ans = 0;
for (int i = k + 1; i > 0; i -= lowbit(i)) {
ans += bit[i];
}
return ans;
}
private:
T bit[n + 1];
int size;
inline int lowbit(int x) const { return x & (-x); }
};
class Prime {
public:
Prime(int num) {
bits.resize(num + 1, true);
sieve();
collect();
}
bool is_prime(int num) const { return bits[num]; }
int find1factor(int num) const {
for (int(i) = (0); (i) < ((int)results.size()); ++(i)) {
if (num % results[i] == 0) {
return results[i];
}
}
return num;
}
private:
vector<bool> bits;
vector<int> results;
void sieve() {
bits[0] = false;
bits[1] = false;
for (int i = 2; i < (int)bits.size(); ++i) {
if (bits[i] == true) {
for (int j = 2;; ++j) {
int v2 = j * i;
if (v2 >= (int)bits.size()) {
break;
}
bits[v2] = false;
}
}
}
}
void collect() {
for (int i = 0; i < (int)bits.size(); ++i) {
if (bits[i]) {
results.push_back(i);
}
}
}
};
template <int n, int m>
struct Graph {
int head[n], edge_id;
struct {
int to, next;
} edges[m];
void init(int num = n) {
edge_id = 0;
memset(head, -1, sizeof(int) * num);
}
int add(int from, int to) {
edges[edge_id].next = head[from];
edges[edge_id].to = to;
head[from] = edge_id;
edge_id++;
return head[from];
}
inline int next(int edge) const { return edges[edge].next; }
inline int to(int edge) const { return edges[edge].to; }
};
template <class T>
inline void hash_combine(std::size_t &seed, const T &v) {
std::hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <typename T, int n>
struct VectorHash {
inline std::size_t operator()(const Vector<T, n> &v) const {
std::size_t seed = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
hash_combine(seed, v[i]);
}
return seed;
}
};
const int max_n = 200000;
int a[max_n];
double b[max_n];
int n;
double maxSum(double A[]) {
double ans = 0, tmp = 0;
for (int i = 0; i < n; i++) {
tmp += A[i];
if (tmp < 0) tmp = 0;
ans = max(ans, tmp);
}
return ans;
}
double calc(double x) {
for (int i = 0; i < n; i++) b[i] = a[i] - x;
double ans1 = maxSum(b);
for (int i = 0; i < n; i++) b[i] = -b[i];
double ans2 = maxSum(b);
return max(ans1, ans2);
}
int main() {
double vmax = -INF, vmin = INF;
scanf(n);
for (int(i) = (0); (i) < (n); ++(i)) {
scanf(a[i]);
vmax = max(vmax, (double)a[i]);
vmin = min(vmin, (double)a[i]);
}
double v1, v2, c1, c2;
while (true) {
v1 = (2 * vmin + vmax) / 3;
v2 = (vmin + 2 * vmax) / 3;
c1 = calc(v1);
c2 = calc(v2);
if (c1 < c2) {
vmax = v2;
} else {
vmin = v1;
}
if (abs(vmax - vmin) < 1e-11) {
break;
}
}
printf(c1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[220005];
double b[220005];
int n;
double check(double x) {
double q1 = 0.0, q2 = 0.0, q3 = 0.0;
for (int i = 1; i <= n; i++) b[i] = a[i] - x;
for (int i = 1; i <= n; i++) q1 = max(b[i], b[i] + q1), q3 = max(q1, q3);
for (int i = 1; i <= n; i++) b[i] = (-1.0) * b[i];
for (int i = 1; i <= n; i++) q2 = max(b[i], b[i] + q2), q3 = max(q3, q2);
return q3;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf", &a[i]);
double l, r;
l = -30000.0, r = 30000.0;
while (r - l > 1e-11) {
double mid1 = (l + r) / 2.0;
double mid2 = (mid1 + r) / 2.0;
if (check(mid1) >= check(mid2))
l = mid1;
else
r = mid2;
}
printf("%.13lf\n", check((l + r) / (2.0)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int X = 100000 + 5;
long double foo1(vector<long double> &v) {
long double s = 0, mx = 0;
for (int i = 0; i < (int)v.size(); i++) {
s += v[i];
mx = max(mx, s);
if (s < 1e-10) s = 0;
}
return mx;
}
long double foo(long double x, vector<long double> v) {
for (int i = 0; i < (int)v.size(); i++) v[i] = v[i] - x;
long double s = foo1(v);
for (int i = 0; i < (int)v.size(); i++) v[i] *= -1;
s = max(s, foo1(v));
for (int i = 0; i < (int)v.size(); i++) v[i] *= -1;
for (int i = 0; i < (int)v.size(); i++) v[i] = v[i] + x;
return s;
}
long double calc(vector<long double> &v) {
long double lo = -1e5, hi = 1e5;
for (int it = 1; it < 100; it++) {
long double ml = lo + (hi - lo) / 3.0, mr = hi - (hi - lo) / 3.0;
if (foo(ml, v) <= foo(mr, v))
hi = mr;
else
lo = ml;
}
return foo(lo, v);
}
void MAIN() {
int n;
long double x;
cin >> n;
vector<long double> v;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
cout << calc(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12);
MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
long long bigmod(long long a, long long b, long long c) {
if (b == 0) return 1 % c;
long long x = bigmod(a, b / 2, c);
x = x * x % c;
if (b % 2 == 1) x = x * a % c;
return x;
}
long long mod_inverse(long long a, long long mod) {
return bigmod(a, mod - 2, mod);
}
double a[2 * 100005];
double b[2 * 100005];
double fun(int n) {
double mx = -1e15;
double sum = 0;
int ptr = 0;
for (int i = 0; i < (n); i++) {
sum += b[i];
while (sum < 0 && ptr <= i) {
sum -= b[ptr++];
}
mx = max(sum, mx);
}
return mx;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n;
for (int i = 0; i < (n); i++) cin >> a[i];
double lw = -100000, hi = 100000, ans = 0, mid, midd;
double res = 1e15;
for (int i = 0; i < (200); i++) {
mid = (lw + lw + hi) / 3.0;
midd = (lw + hi + hi) / 3.0;
for (int i = 0; i < (n); i++) {
b[i] = a[i] - mid;
}
double d1 = fun(n);
for (int i = 0; i < (n); i++) {
b[i] *= -1.0;
}
double d2 = fun(n);
double mx = max(d1, d2);
for (int i = 0; i < (n); i++) {
b[i] = a[i] - midd;
}
d1 = fun(n);
for (int i = 0; i < (n); i++) {
b[i] *= -1.0;
}
d2 = fun(n);
double mxx = max(d1, d2);
if (mx < mxx) {
hi = midd;
ans = mid;
res = mx;
} else {
lw = mid;
ans = midd;
res = mxx;
}
}
cout << fixed << setprecision(10) << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
const int N = 200000 + 19;
int A[N], n;
double B[N], l, r, res, tmp;
double calc(double x) {
res = 0;
for (int i = 1; i < n + 1; i++) B[i] = A[i] - x;
tmp = 0;
for (int i = 1; i < n + 1; i++) {
tmp = max(tmp, 0.0) + B[i];
res = max(res, abs(tmp));
}
tmp = 0;
for (int i = 1; i < n + 1; i++) {
tmp = min(tmp, 0.0) + B[i];
res = max(res, abs(tmp));
}
return res;
}
int main() {
n = IN();
for (int i = 1; i < n + 1; i++) A[i] = IN();
l = -10000, r = 10000;
for (int i = 0; i < 100; i++) {
double t = (r - l) / 3.0;
double t1 = l + t, t2 = r - t;
if (calc(t1) > calc(t2))
l = t1;
else
r = t2;
}
printf("%.10lf\n", calc(l));
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
double w[200005];
double mx[200005], mn[200005];
double ans = 1e16;
double cal(double x) {
mx[0] = mn[0] = 0;
double ans = 0;
for (int i = 1; i <= n; i++) {
mx[i] = max(0.0, mx[i - 1]) + w[i] - x;
mn[i] = min(0.0, mn[i - 1]) + w[i] - x;
ans = max(ans, max(fabs(mx[i]), fabs(mn[i])));
}
return ans;
}
int main() {
n = Get();
for (int i = 1; i <= n; i++) {
scanf("%lf", &w[i]);
}
long double l = -10001, r = 10001, mid, rmid;
while (l + 1e-13 < r) {
mid = (l + r) / 2;
rmid = (mid + r) / 2;
double lx = cal(mid), rx = cal(rmid);
if (lx + 1e-13 > rx) {
ans = min(ans, rx);
l = mid + 1e-13;
} else {
ans = min(ans, lx);
r = rmid - 1e-13;
}
}
printf("%.6lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int n;
double cal(double x) {
double t1 = 0, t2 = 0, maxsum = -1320, minsum = 1320;
for (int i = 1; i <= n; i++) {
if (t1 >= 0) {
t1 += a[i] - x;
} else {
t1 = a[i] - x;
}
if (t2 <= 0) {
t2 += a[i] - x;
} else {
t2 = a[i] - x;
}
maxsum = max(maxsum, t1);
minsum = min(minsum, t2);
}
return max(fabs(maxsum), fabs(minsum));
}
double triple(double L, double R) {
int t = 100;
while (t--) {
double mid = L + (R - L) / 3.0;
double mmid = R - (R - L) / 3.0;
if (cal(mid) > cal(mmid))
L = mid;
else
R = mmid;
}
return cal(L) > cal(R) ? L : R;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
printf("%.7lf\n", cal(triple(-10005, 10005)));
}
|
#include <bits/stdc++.h>
using namespace std;
void fio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
double solve(double mid, vector<double> vec, double n) {
for (int i = 0; i < n; i++) {
vec[i] = vec[i] - mid;
}
double cur_sum = vec[0], max_sum = vec[0];
double cur_min = vec[0], min_sum = vec[0];
for (int i = 1; i < n; i++) {
cur_sum = max(cur_sum + vec[i], vec[i]);
max_sum = max(max_sum, cur_sum);
cur_min = min(cur_min + vec[i], vec[i]);
min_sum = min(cur_min, min_sum);
}
return max(max_sum, abs(min_sum));
}
int main() {
fio();
cout << fixed << setprecision(14);
double n;
cin >> n;
vector<double> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
double l = -(1e4 + 7), r = 1e4 + 7;
for (int i = 0; i < 300; i++) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
double f1 = solve(m1, vec, n);
double f2 = solve(m2, vec, n);
if (f1 < f2)
r = m2;
else
l = m1;
}
double mid = r;
for (int i = 0; i < n; i++) {
vec[i] = vec[i] - mid;
}
double cur_sum = vec[0], max_sum = vec[0];
double cur_min = vec[0], min_sum = vec[0];
for (int i = 1; i < n; i++) {
cur_sum = max(cur_sum + vec[i], vec[i]);
max_sum = max(max_sum, cur_sum);
cur_min = min(cur_min + vec[i], vec[i]);
min_sum = min(cur_min, min_sum);
}
cout << max(max_sum, abs(min_sum)) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long normalize(long long x, long long mod) {
x %= mod;
if (x < 0) x += mod;
return x;
}
long long dx[4] = {0, 0, 1, -1};
long long dy[4] = {1, -1, 0, 0};
string abc = "abcdefghijklmnopqrstuvwxyz";
const double PI = acosl(-1);
const long long mod = 998244353;
const long long inf = 1e18 + 5;
inline long long add(long long a, long long b, long long p = mod) {
long long c = a + b;
if (c >= p) c -= p;
return c;
}
inline long long sub(long long a, long long b, long long p = mod) {
long long c = a - b;
if (c < 0) c += p;
return c;
}
inline long long mul(long long a, long long b, long long p = mod) {
return (a * 1ll * b) % p;
}
long long floor1(long long n, long long k) {
if (n % k == 0 || n >= 0) return n / k;
return (n / k) - 1;
}
long long ceil1(long long n, long long k) { return floor1(n + k - 1, k); }
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
const long long N = 2e5 + 5;
long long n, m, k;
long long a[N], b[N];
long double cache[N];
long double dp() {
long double mx = 0.0;
long double cur = 0.0;
for (long long i = (1); i < (n + 1); ++i) {
if (cur + cache[i] > cache[i])
cur = cur + cache[i];
else
cur = cache[i];
if (cur > mx) mx = cur;
}
return mx;
}
long double f(long double x) {
long double ans = 0.0;
for (long long i = (1); i < (n + 1); ++i) cache[i] = a[i] - x;
ans = max(ans, dp());
for (long long i = (1); i < (n + 1); ++i) cache[i] = -cache[i];
ans = max(ans, dp());
return ans;
}
long double ternary_search(long double l, long double r) {
long double eps = 1e-12;
while (r - l > eps) {
long double m1 = l + (r - l) / 3.00;
long double m2 = r - (r - l) / 3.00;
long double f1 = f(m1);
long double f2 = f(m2);
if (f1 > f2)
l = m1;
else
r = m2;
}
return f(l);
}
void solve() {
cin >> n;
for (long long i = (1); i < (n + 1); ++i) cin >> a[i];
cout << ternary_search(-20005, 20005) << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double v[200010];
double func(double x) {
double mn = 0, mx = 0, a = 0, b = 0;
for (int i = 0; i < n; i++) {
a += v[i] - x;
b += v[i] - x;
mn = min(mn, a);
mx = max(mx, b);
if (a > 0) a = 0;
if (b < 0) b = 0;
}
return max(mx, -mn);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf", &v[i]);
double st, ed;
st = -10000;
ed = 10000;
for (int i = 0; i < 100; i++) {
double p1 = st + (ed - st) / 3.0;
double p2 = ed - (ed - st) / 3.0;
if (func(p1) >= func(p2))
st = p1;
else
ed = p2;
}
printf("%.7lf\n", func(st));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
std::istream& operator>>(std::istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& out, pair<T1, T2>& a) {
out << a.first << " " << a.second;
return out;
}
const long long N = 2e5 + 5;
long long a[N];
double b[N];
long long n;
double calc(double x) {
for (long long i = 0; i < n; i++) b[i + 1] = a[i] - x;
double s = 0, ans = 0;
b[0] = 0;
for (long long i = 1; i < n + 1; i++) {
b[i] += b[i - 1];
}
double l = 0, u = 0;
for (long long i = 1; i < n + 1; i++) {
ans = max(ans, abs(b[i] - l));
ans = max(ans, abs(b[i] - u));
l = min(l, b[i]);
u = max(u, b[i]);
}
return ans;
}
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
double L = -10002, U = 10002;
for (long long i = 0; i < 90; i++) {
double d = (U - L) / 3;
if (calc(L + d) > calc(L + 2 * d)) {
L = L + d;
} else {
U = U - d;
}
}
cout << calc(L);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(9);
cout << fixed;
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, -1, 1};
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const long long INFLL = 0x7FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);
template <class T>
T take(queue<T> &O) {
T tmp = O.front();
O.pop();
return tmp;
}
template <class T>
T take(stack<T> &O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <class T>
T take(priority_queue<T> &O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <class T>
inline void getint(T &num) {
bool neg = 0;
num = 0;
char c;
while ((c = getchar_unlocked()) && (!isdigit(c) && c != '-'))
;
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
do num = num * 10 + c - '0';
while ((c = getchar_unlocked()) && isdigit(c));
if (neg) num = -num;
}
template <class T>
inline bool inRange(T z, T a, T b) {
return a <= z && z <= b;
}
void OPEN(string in = "input.txt", string out = "output.txt") {
freopen(in.c_str(), "r", stdin);
freopen(out.c_str(), "w", stdout);
return;
}
int arr[200005];
int n;
vector<int> vc;
inline double cek(double x) {
double tmp = 0.0, ansz = 0.0;
for (int(i) = (0), _t = (n); i < (_t); ++(i)) {
tmp = max(tmp + arr[i] - x, 0.0);
ansz = max(ansz, tmp);
}
tmp = 0.0;
for (int(i) = (0), _t = (n); i < (_t); ++(i)) {
tmp = max(tmp + -(arr[i] - x), 0.0);
ansz = max(ansz, tmp);
}
return ansz;
}
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int(i) = (0), _t = (n); i < (_t); ++(i)) cin >> arr[i];
double lo = -10000.0, hi = 10000.0, le, ri;
for (int(i) = (0), _t = (120); i < (_t); ++(i)) {
le = lo + (hi - lo) / 3.;
ri = lo + (hi - lo) * 2. / 3.;
double cle = cek(le), cri = cek(ri);
if (cle < cri)
hi = ri;
else if (cle > cri)
lo = le;
else {
lo = le;
hi = ri;
}
}
cout << fixed << setprecision(10) << cek(lo) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int a[N], n;
double ans(double x) {
double arr[N];
for (int i = 0; i < n; i++) arr[i] = a[i] - x;
double neg = 0;
double pos = 0;
double ans = 0;
for (int i = 0; i < n; i++) {
if (neg > 0) neg = 0;
if (pos < 0) pos = 0;
neg += arr[i];
pos += arr[i];
ans = max(ans, max(-neg, pos));
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
double l = -1e5 - 9, r = 1e5 + 9;
for (int i = 0; i < 100; i++) {
double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (ans(m1) > ans(m2))
l = m1;
else
r = m2;
}
cout << setprecision(12) << fixed << ans(l) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double n, a[200005], sum[200005];
const double EPS = 0.000000000005;
double f(double x) {
double ans = -999999999, t_sum = 0, max_sum = -999999999, min_sum = 999999999,
temp;
for (int i = 0; i < n; i++) {
t_sum += a[i] - x;
sum[i] = t_sum;
}
for (int i = 0; i < n; i++) {
ans = max(ans, abs(sum[i]));
if (i != 0) {
if (sum[i] < 0) {
temp = sum[i] - max_sum;
ans = max(ans, abs(temp));
} else {
temp = sum[i] - min_sum;
ans = max(ans, abs(temp));
}
}
if (sum[i] > max_sum) {
max_sum = sum[i];
}
if (sum[i] < min_sum) {
min_sum = sum[i];
}
}
return ans;
}
double solve() {
double l = -10000, r = 10000, m1, m2;
while (r - l > EPS) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
if (f(m1) < f(m2)) {
r = m2;
} else {
l = m1;
}
}
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << fixed << setprecision(7) << f(solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(int a, int b) { return a > b; }
class Compare {
public:
bool operator()(int a, int b) { return a > b; }
};
int mod(int a, int b) { return ((a % b) + b) % b; }
int n, a[200009];
double f(double x) {
double g_mx = -100000000000, l_mx = 0, l_mn = 0;
for (int i = 0; i < n; i++) {
double q = a[i] - x, p1 = l_mx + q, p2 = l_mn + q;
l_mx = max(q, p1), l_mn = min(q, p2);
g_mx = max(g_mx, max(fabs(l_mn), fabs(l_mx)));
}
return g_mx;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double l = -100000.0, r = 100000.0, m1, m2;
for (int i = 0; i < 250; i++) {
m1 = l + (r - l) / 3.0;
m2 = r - (r - l) / 3.0;
if (f(m1) > f(m2))
l = m1;
else
r = m2;
}
printf("%.12lf\n", f(m1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int n;
long double ans = 10000000000;
long double test(long double x) {
long double sum = 0;
long double mn = 0;
long double mx = 0;
long double ret = 0;
for (int i = 0; i < n; i++) {
sum += (a[i] - x);
ret = max(ret, abs(sum - mn));
ret = max(ret, abs(sum - mx));
mn = min(mn, sum);
mx = max(mx, sum);
}
ans = min(ans, ret);
return ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long double s = -10000000, e = 10000000;
while (e - s > 1e-12) {
long double t1 = s + (e - s) / 3;
long double t2 = s + (e - s) * 2 / 3;
long double v1 = test(t1);
long double v2 = test(t2);
if (v1 < v2) {
e = t2;
} else {
s = t1;
}
}
printf("%.9Lf", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200005], b[200005], r = -10005, l = 10005, midl, midr, sum, ans;
double weakn(double m) {
ans = 0;
sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i] - m;
if (sum < 0) sum = 0;
ans = max(ans, sum);
}
sum = 0;
for (int i = 0; i < n; i++) {
sum += m - a[i];
if (sum < 0) sum = 0;
ans = max(ans, sum);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
if (a[i] > r) r = a[i];
if (a[i] < l) l = a[i];
}
while (r - l > 2e-12) {
midl = (l + r) / 2;
midr = (midl + r) / 2;
if (weakn(midl) < weakn(midr))
r = midr;
else
l = midl;
}
printf("%lf", weakn(l));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N], n;
double solve(double x) {
double ma = -1, now = 0;
for (int i = 0; i < n; i++) ma = max(ma, now = max(0.0, now + a[i] - x));
now = 0;
for (int i = 0; i < n; i++) ma = max(ma, now = max(0.0, now + x - a[i]));
return ma;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
double l = -1e4, r = 1e4;
int T = 200;
while (T--) {
double m = (l + r) / 2, ml = (l + m) / 2, mr = (r + m) / 2;
if (solve(ml) <= solve(mr))
r = mr;
else
l = ml;
}
printf("%.15f\n", solve(l));
return 0;
}
|
#include <bits/stdc++.h>
int a[200000];
double diff[200000];
double getAns(int n, double x) {
for (int i = 0; i < n; i++) {
diff[i] = a[i] - x;
}
double small = 0, big = 0, min = 0, max = 0;
for (int i = 0; i < n; i++) {
small += diff[i];
min = std::min(min, small);
if (small > 0) small = 0;
big += diff[i];
max = std::max(max, big);
if (big < 0) big = 0;
}
return std::max(max, -min);
}
double trinarySearch(int n, double left, double right) {
int t = 100;
while (t--) {
double mid1 = left + (right - left) / 3;
double mid2 = left + 2 * (right - left) / 3;
double ans1 = getAns(n, mid1);
double ans2 = getAns(n, mid2);
if (ans1 == ans2) {
left = mid1;
right = mid2;
} else if (ans1 < ans2) {
right = mid2;
} else {
left = mid1;
}
}
return (left + right) / 2;
}
int main() {
int n;
scanf("%d", &n);
int max = -10000, min = 10000;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (max < a[i]) max = a[i];
if (min > a[i]) min = a[i];
}
double x = trinarySearch(n, min, max);
printf("%.10f\n", getAns(n, x));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i;
int mn;
int a[400010];
double mx, sum, l, r, mid, mmid;
double d[400010];
double f(double x) {
mx = 0;
for (i = 1; i <= n; i++) d[i] = a[i] - x;
if (d[1] >= 0)
sum = d[1];
else
sum = 0;
for (i = 2; i <= n; i++) {
if (sum - mx > 1e-30) mx = sum;
if (d[i] + sum >= 0) {
sum += d[i];
continue;
}
sum = 0;
}
if (sum - mx > 1e-30) mx = sum;
for (i = 1; i <= n; i++) d[i] = x - a[i];
if (d[1] >= 0)
sum = d[1];
else
sum = 0;
for (i = 2; i <= n; i++) {
if (sum - mx > 1e-30) mx = sum;
if (d[i] + sum >= 0) {
sum += d[i];
continue;
}
sum = 0;
}
if (sum - mx > 1e-30) mx = sum;
return mx;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mn = max(mn, a[i]);
mn = max(mn, -a[i]);
}
l = -mn;
r = mn;
while (l < r - 4e-12) {
mid = (l + r) / 2;
mmid = (mid + r) / 2;
if (f(mid) <= f(mmid))
r = mmid;
else
l = mid;
}
printf("%.7f", f(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-11;
vector<double> a;
double okk(double m) {
long long n = a.size();
double ans = 0;
double tmp[n], pf[n];
for (long long i = 0; i < n; i++) {
tmp[i] = a[i] - m;
if (i == 0)
pf[i] = tmp[i];
else
pf[i] = pf[i - 1] + tmp[i];
}
double mn = 0;
for (long long i = 0; i < n; i++) {
ans = max(ans, pf[i] - mn);
mn = min(mn, pf[i]);
pf[i] *= -1;
}
mn = 0;
for (long long i = 0; i < n; i++) {
ans = max(ans, pf[i] - mn);
mn = min(mn, pf[i]);
}
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(15) << fixed;
long long n;
cin >> n;
a.resize(n);
set<long long> st;
for (long long i = 0; i < n; i++) {
cin >> a[i];
st.insert(a[i]);
}
if (st.size() == 1) {
cout << 0 << '\n';
return 0;
}
double l = -1e6, r = 1e6, ans = 1e15;
while (r - l > eps) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
double t1 = okk(m1);
double t2 = okk(m2);
ans = min(ans, t1);
ans = min(ans, t2);
if (t1 > t2)
l = m1;
else
r = m2;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
double a[N];
double max_poor(double x) {
int i;
double pre, mpre, ret = 0;
pre = mpre = 0;
for (i = 0; i < n; i++) {
pre += a[i] - x;
ret = max(ret, abs(pre - mpre));
mpre = min(mpre, pre);
}
pre = mpre = 0;
for (i = 0; i < n; i++) {
pre += a[i] - x;
ret = max(ret, abs(pre - mpre));
mpre = max(mpre, pre);
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int i;
double l = 0.0, h = 0.0, m1, m2;
cin >> n;
for (i = 0; i < n; h = max(h, abs(a[i])), i++) cin >> a[i];
l = -h;
for (i = 0; i < 300; i++) {
m1 = l + (h - l) / 3;
m2 = h - (h - l) / 3;
if (max_poor(m1) > max_poor(m2))
l = m1;
else
h = m2;
}
printf("%.17f\n", max_poor(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e9;
vector<int> a;
int n;
double Solve(double x) {
double _max = 0.0;
double _temp = 0.0;
double sum = 0.0;
for (int i = 0; i < n; i++) {
sum = max(sum + a[i] - x, a[i] - x);
_max = max(_max, sum);
}
sum = 0.0;
for (int i = 0; i < n; i++) {
sum = max(sum + x - a[i], x - a[i]);
_temp = max(_temp, sum);
}
return max(_max, _temp);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.emplace_back(x);
}
double left = -INF;
double right = INF;
double mid_L, mid_R;
double fx, fy;
for (int i = 0; i < 300; i++) {
mid_L = left + (right - left) / 3;
mid_R = right - (right - left) / 3;
fx = Solve(mid_L);
fy = Solve(mid_R);
if (fx < fy)
right = mid_R;
else
left = mid_L;
}
cout << setprecision(11) << fixed << fx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double poorness(vector<int> v, double x) {
double total_max = abs(v[0] - x);
double max_sum = v[0] - x;
double min_sum = v[0] - x;
double sum_total_max = max_sum;
double sum_total_min = min_sum;
for (int i = 1; i < v.size(); i++) {
max_sum = max(v[i] - x, v[i] + max_sum - x);
min_sum = min(v[i] - x, v[i] + min_sum - x);
sum_total_max = max(sum_total_max, max_sum);
sum_total_min = min(sum_total_min, min_sum);
total_max = max(abs(sum_total_max), abs(sum_total_min));
}
return total_max;
}
double ternary_search(vector<int> v, double left, double right, int step) {
if (step == 150) {
return poorness(v, (right + left) / 2);
}
double new_left = left + (right - left) / 3;
double new_right = new_left + (right - left) / 3;
if (poorness(v, new_left) < poorness(v, new_right)) {
return ternary_search(v, left, new_right, step + 1);
} else {
return ternary_search(v, new_left, right, step + 1);
}
}
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
cout << fixed << setprecision(15);
cout << ternary_search(v, -10001, 10001, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 201010;
int N;
double arr[MAXN];
double brr[MAXN];
double calc() {
double sum = 0;
double ans = 0;
double curmin = 0;
for (int i = 0; i < N; i++) {
sum += brr[i];
ans = max(ans, sum - curmin);
curmin = min(curmin, sum);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) cin >> arr[i];
double lb = -22222, rb = 22222;
while (rb - lb > 1E-11) {
double mb = (lb + rb) / 2;
for (int i = 0; i < N; i++) brr[i] = arr[i] + mb;
double maxsum = calc();
for (int i = 0; i < N; i++) brr[i] = -arr[i] - mb;
double minsum = calc();
if (maxsum > minsum)
rb = mb;
else
lb = mb;
}
double ans = (lb + rb) / 2;
for (int i = 0; i < N; i++) brr[i] = arr[i] + ans;
double out = calc();
cout << fixed << setprecision(12) << out << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
long long int n;
long double arr[1000000];
long double solve(long double mid) {
double maxi = 0.0, sum = 0.0;
for (long long int i = 0; i < n; i++) {
sum += (arr[i] - mid);
if (sum < 0) {
sum = 0;
}
maxi = max(abs(sum), maxi);
}
sum = 0.0;
for (long long int i = 0; i < n; i++) {
sum += (arr[i] - mid);
if (sum > 0) {
sum = 0;
}
maxi = max(abs(sum), maxi);
}
return maxi;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
long double lo = -10000.0, hi = 10000.0, mid1, mid2;
for (long long int i = 1; i <= 100; i++) {
mid1 = lo + (hi - lo) / 3;
mid2 = hi - (hi - lo) / 3;
if (solve(mid1) >= solve(mid2)) {
lo = mid1;
} else {
hi = mid2;
}
}
cout << fixed << setprecision(10) << solve(lo) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
double a[222222];
int n;
double check(double x) {
double sum = 0;
double ans = 0;
for (int i = 0; i < n; i++) {
if (sum + a[i] - x < a[i] - x) {
sum = a[i] - x;
} else
sum += a[i] - x;
ans = max(ans, sum);
}
sum = 0;
for (int i = 0; i < n; i++) {
if (sum + (-(a[i] - x)) < (-(a[i] - x))) {
sum = (-(a[i] - x));
} else
sum += (-(a[i] - x));
ans = max(ans, sum);
}
return ans;
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
}
double l = -1e9;
double r = 1e9;
double ans;
double mid;
double mmid;
for (int i = 0; i < 700; i++) {
mid = l + (r - l) / 3.0;
mmid = r - (r - l) / 3.0;
if (check(mid) <= check(mmid))
r = mmid;
else
l = mid;
}
printf("%f\n", check(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 3e-12;
int n;
double a[200005], b[200005];
double maxsum() {
double ans = 0, tmp = 0;
for (int i = 1; i <= n; i++) {
tmp += b[i];
if (tmp < 0) tmp = 0;
ans = max(tmp, ans);
}
return ans;
}
double cal(double x) {
for (int i = 1; i <= n; i++) b[i] = a[i] - x;
double ans1 = maxsum();
for (int i = 1; i <= n; i++) b[i] = -b[i];
double ans2 = maxsum();
return max(ans1, ans2);
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%lf", &a[i]);
double l = -10005, r = 10005;
while (r - l > eps) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
if (cal(m1) < cal(m2))
r = m2;
else
l = m1;
}
printf("%.15f\n", cal(l));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v1;
pair<int, int> p1;
double a[1234567];
string s;
int dp[1001];
double max1 = 0.0000000000, max2 = 0.00000000;
double b[200001];
int n;
double check(double b[]) {
int i;
double max_upto = 0.0000, overall = 0.0000;
for (i = 0; i < n; i++) {
max_upto += b[i];
if (max_upto > overall) overall = max_upto;
if (max_upto < 0) max_upto = 0;
}
return overall;
}
int main() {
int t;
int i, j, k, m;
scanf("%d", &n);
for (i = 0; i < n; i++) cin >> a[i];
double l = -1000000000.0000;
double h = 1000000000, mid;
for (j = 0; j < 100; j++) {
mid = (l + h) / 2;
for (i = 0; i < n; i++) b[i] = a[i] - mid;
max1 = check(b);
for (i = 0; i < n; i++) b[i] *= (-1);
max2 = check(b);
if (max1 > max2)
l = mid;
else
h = mid;
}
printf("%.12lf\n", max(max1, max2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double arr[200005];
int n;
double solve(double x) {
double ans1 = 0, ans2 = 0;
double val = 0;
for (int i = 0; i < n; i++) {
val += (arr[i] - x);
if (val > ans1) ans1 = val;
if (val < 0) val = 0;
}
val = 0;
for (int i = 0; i < n; i++) {
val += (arr[i] - x);
if (val < ans2) ans2 = val;
if (val > 0) val = 0;
}
return max(ans1, -ans2);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
double l1 = -100000, l2 = 100000;
double mid1, mid2;
for (int i = 0; i < 100; i++) {
mid1 = (l1 + l2) / 2.0;
mid2 = (mid1 + l2) / 2.0;
if (solve(mid1) < solve(mid2)) {
l2 = mid2;
} else {
l1 = mid1;
}
}
cout << fixed << setprecision(9) << solve(l2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e5;
int a[SIZE], n;
double f(double x) {
double ma = 0, mi = 0, now = 0;
double res = 0;
for (int i = 1; i <= n; i++) {
now += a[i] - x;
res = max(res, fabs(ma - now));
res = max(res, fabs(mi - now));
ma = max(ma, now);
mi = min(mi, now);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
double ll = -10000, rr = 10000;
for (int k = 0; k < 100; k++) {
double mm1 = ll * 0.54 + rr * 0.46;
double mm2 = ll * 0.46 + rr * 0.54;
double v1 = f(mm1);
double v2 = f(mm2);
if (v1 > v2)
ll = mm1;
else
rr = mm2;
}
printf("%.15f\n", f((ll + rr) * 0.5));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int len(const T& a) {
return a.size();
}
using ll = long long;
constexpr long double EPS = 1e-7;
long double MaxSubarray(const vector<long double>& a) {
long double best = -1e8;
long double cur = 0.0;
for (auto& i : a) {
cur = max((long double)0, cur + i);
best = max(best, cur);
}
return best;
}
long double MinSubarray(const vector<long double>& a) {
long double best = 1e8;
long double cur = 0.0;
for (auto& i : a) {
cur = min((long double)0, cur + i);
best = min(best, cur);
}
return best;
}
long double Check(const vector<long double>& a, long double x) {
vector<long double> new_a(a.size());
for (int i = 0; i < len(a); ++i) {
new_a[i] = (long double)a[i] - x;
}
return max(abs(MaxSubarray(new_a)), abs(MinSubarray(new_a)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(6);
int n;
cin >> n;
vector<long double> a(n);
for (auto& i : a) cin >> i;
long double l = -1e4 - 10, r = 1e4 + 10;
for (int step = 0; step < 200; ++step) {
long double m1 = l + (r - l) / 3.0;
long double m2 = r - (r - l) / 3.0;
if (Check(a, m1) - Check(a, m2) > EPS) {
l = m1;
} else {
r = m2;
}
}
cout << Check(a, l);
return 0;
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
int a[2 * 100000 + 5];
int n;
int i, j;
double X(double x) {
vector<double> v;
for (int j = 0; j < n; j++) v.push_back(a[j] - x);
double curmax = 0;
double sum = 0;
for (j = 0; j < n; j++) {
sum += v[j];
if (curmax < 0 && sum >= 0) {
if (abs(curmax) < abs(sum - curmax)) {
double k = curmax;
curmax = sum - k;
sum = sum - k;
}
} else if (curmax >= 0 && sum <= 0) {
if (abs(curmax) < abs(-curmax + sum)) {
double k = curmax;
curmax = -k + sum;
sum = -k + sum;
}
} else {
if (abs(curmax) < abs(sum)) {
curmax = sum;
}
}
}
return abs(curmax);
}
int main() {
scanf("%d", &n);
for (j = 0; j < n; j++) scanf("%d", &a[j]);
double lo = -10001;
double hi = 10001;
i = 0;
while (i != 300) {
double g = lo + (hi - lo) / 3.0;
double h = hi - (hi - lo) / 3.0;
if (X(g) < X(h)) {
hi = h;
} else
lo = g;
i++;
}
cout << fixed << setprecision(10) << X(lo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 24;
int n;
double a[maxn];
double cal(double x) {
double ans1 = 0.0, tmp1 = 0.0, ans2 = 0.0, tmp2 = 0.0;
for (int i = 1; i <= n; ++i) {
double k = a[i] - x;
tmp1 = max(tmp1 + k, 0.0);
tmp2 = max(tmp2 - k, 0.0);
ans1 = max(ans1, tmp1);
ans2 = max(ans2, tmp2);
}
return max(ans1, ans2);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf", &a[i]);
double eps = 1e-6 / n / 2 * 1.0;
double l = -10000.0, r = 10000.0, m1 = 0.0, m2 = 0.0, ans = 0.0;
while (r - l > eps) {
m1 = l + (r - l) / 3.0;
m2 = r - (r - l) / 3.0;
if (cal(m1) >= cal(m2))
l = ans = m1;
else
r = ans = m2;
}
printf("%.10lf\n", cal(ans));
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> A;
void calc(double x, double& pos, double& neg) {
double max_ending_here = (A[0] - x);
double max_from_start = (A[0] - x);
for (int i = 1; i < A.size(); i++) {
if (max_ending_here + (A[i] - x) < (A[i] - x)) {
max_ending_here = (A[i] - x);
} else {
max_ending_here += (A[i] - x);
}
max_from_start = max(max_from_start, max_ending_here);
}
pos = max_from_start;
max_ending_here = -(A[0] - x);
max_from_start = -(A[0] - x);
for (int i = 1; i < A.size(); i++) {
if (max_ending_here + (-(A[i] - x)) < (-(A[i] - x))) {
max_ending_here = (-(A[i] - x));
} else {
max_ending_here += (-(A[i] - x));
}
max_from_start = max(max_from_start, max_ending_here);
}
neg = max_from_start;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
A.push_back(t);
}
double lo = -11111, hi = 11111;
for (int i = 0; i < 100; i++) {
double a = (lo * 2 + hi) / 3;
double b = (lo + hi * 2) / 3;
double t, s;
calc(a, t, s);
double aa = max(t, s);
calc(b, t, s);
double bb = max(t, s);
if (aa < bb) {
hi = b;
} else {
lo = a;
}
}
double ans1, ans2;
calc((lo + hi) / 2, ans1, ans2);
printf("%.8lf\n", max(ans1, ans2));
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const ll inf = 0x3f3f3f3f3f;
const double eps = 1e-9;
int n;
int t[200010];
double now, max_glo, min_glo;
double a, b, m1, m2, res;
double f(double x) {
now = 0;
max_glo = -llinf;
for (int i = 0; i < n; i++) {
if (0 > now) {
now = t[i] - x;
} else {
now += t[i] - x;
}
if (max_glo < now) {
max_glo = now;
}
}
now = 0;
min_glo = llinf;
for (int i = 0; i < n; i++) {
if (0 < now) {
now = t[i] - x;
} else {
now += t[i] - x;
}
if (min_glo > now) {
min_glo = now;
}
}
return max(abs(max_glo), abs(min_glo));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> t[i];
int mx = -inf;
int mn = inf;
for (int i = 0; i < n; i++) {
mx = max(mx, t[i]);
mn = min(mn, t[i]);
}
a = mn;
b = mx;
int cnt = 0;
while (cnt++ < 200) {
m1 = a + (b - a) / 3;
m2 = b - (b - a) / 3;
if (f(m1) < f(m2)) {
b = m2;
} else {
a = m1;
}
}
cout << fixed << f(b) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double tong(double x, vector<double> a) {
double maxt = 0, mint = 0, s = 0;
for (int i = 0; i < a.size(); i++) {
s += a[i] - x;
maxt = max(s, maxt);
mint = min(s, mint);
}
return abs(maxt - mint);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<double> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
double l = -20000, r = 20000;
for (int i = 0; i < 100; i++) {
double l1 = (l + l + r) / 3;
double r1 = (l + r + r) / 3;
if (tong(l1, a) > tong(r1, a)) {
l = l1;
} else
r = r1;
}
cout << setprecision(6) << fixed << tong(l, a);
return 0;
}
|
#include <bits/stdc++.h>
double a[2000005];
double f(double x, int n) {
int i;
double sum[200005] = {0}, maxl = 0, minl = 0;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i - 1] - x;
if (maxl < sum[i]) maxl = sum[i];
if (minl > sum[i]) minl = sum[i];
}
return maxl - minl;
}
double solve(double l, double r, int n) {
double mid, mid2;
int t = 200;
while (t--) {
mid = (l + r) / 2.0;
mid2 = (mid + r) / 2.0;
if (f(mid, n) < f(mid2, n))
r = mid2;
else
l = mid;
}
return l;
}
int main() {
int n, i;
double hzb;
while (~scanf("%d", &n)) {
for (i = 0; i < n; i++) scanf("%lf", &a[i]);
hzb = solve(-1e9, 1e9, n);
printf("%.15lf\n", f(hzb, n));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i];
double l = *min_element(a.begin(), a.end());
double r = *max_element(a.begin(), a.end());
double mx = 0, mn = 0;
while (r - l > 1e-12) {
double mid = (l + r) / 2, sum1 = 0, sum2 = 0;
mx = mn = 0;
for (int i = 0; i < n; i++) {
sum1 += a[i] - mid;
if (sum1 < 0) sum1 = 0;
if (sum1 > mx) mx = sum1;
sum2 += a[i] - mid;
if (sum2 > 0) sum2 = 0;
if (sum2 < mn) mn = sum2;
}
if (mx + mn > 0)
l = mid;
else
r = mid;
}
printf("%.12f\n", max(mx, abs(mn)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
double g[200100], f[200100], a[233333];
int n;
double equ(double x) {
double ans = 0;
g[0] = 0;
f[0] = 0;
double maxn = -1e20, minn = 1e20;
for (int i = 1; i <= n; i++) {
f[i] = max(f[i - 1] + a[i] - x, a[i] - x);
maxn = max(maxn, f[i]);
g[i] = min(g[i - 1] + a[i] - x, a[i] - x);
minn = min(minn, g[i]);
}
ans = max(maxn, fabs(minn));
return ans;
}
double ternarySearch(double l, double r) {
for (int i = 1; i <= 233; i++) {
double ll = (2 * l + r) / 3;
double rr = (l + 2 * r) / 3;
double ans1 = equ(ll);
double ans2 = equ(rr);
if (ans1 > ans2)
l = ll;
else
r = rr;
}
return l;
}
int main() {
scanf("%d", &n);
double maxn = 100000.0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
}
double ans = ternarySearch(-maxn, maxn);
ans = equ(ans);
printf("%.8lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010], n;
double Get_weekness(double x) {
double k1 = 0.0, k2 = 0.0, res = 0.0;
for (int i = 0; i < n; i++) {
k1 += a[i] - x;
k2 += a[i] - x;
if (k1 < 0) k1 = 0.0;
if (k2 > 0) k2 = 0.0;
if (k1 > res) res = k1;
if (-k2 > res) res = -k2;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double l = -99999.99, r = 99999.99;
for (int i = 0; i < 100; i++) {
double k1 = l / 3 * 2 + r / 3;
double k2 = l / 3 + r / 3 * 2;
if (Get_weekness(k1) > Get_weekness(k2))
l = k1;
else
r = k2;
}
printf("%.12f\n", Get_weekness(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long int GCD(long long int x, long long int y) {
if (x < y) swap(x, y);
if (x == 0) return y;
if (y == 0) return x;
return GCD(x % y, y);
}
long long int phi(long long int n) {
long long int result = n;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
}
if (n > 1) result -= result / n;
return result;
}
long long int power(long long int x, long long int n, long long int mod) {
long long int res = 1;
x %= mod;
while (n) {
if (n & 1) {
res = ((res * x) % mod + mod) % mod;
}
x = ((x * x) % mod + mod) % mod;
n >>= 1;
}
return res;
}
const long double eps = 1e-12;
const int MAXN = 200005;
long double N, A[MAXN], Al[MAXN];
long double process(long double x) {
for (long long int i = 1; i <= N; i++) {
Al[i] = A[i] - x;
}
long double sum = 0;
long double mx = -1e18 + 9;
for (long long int i = 1; i <= N; i++) {
sum += Al[i];
if (sum < 0) sum = 0;
mx = max(mx, sum);
}
for (long long int i = 1; i <= N; i++) {
Al[i] = -Al[i];
}
sum = 0;
for (long long int i = 1; i <= N; i++) {
sum += Al[i];
if (sum < 0) sum = 0;
mx = max(mx, sum);
}
return mx;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> N;
for (long long int i = 1; i <= N; i++) {
cin >> A[i];
}
long double l = -10000.0, r = 10000.0;
while (r - l > eps) {
long double mid1 = l + (long double)(r - l) / (long double)3.0;
long double mid2 = r - (long double)(r - l) / (long double)3.0;
if (process(mid1) < process(mid2)) {
r = mid2;
} else {
l = mid1;
}
}
long double ans = process(l);
cout << setprecision(10) << fixed << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using ulli = unsigned long long int;
using ld = long double;
int n;
ld a[(int)(2e5 + 5)];
ld f(ld x) {
ld ans = 0;
ld temp = 0;
for (int i = 0; i < n; ++i) {
temp += a[i] - x;
if (temp < 0) temp = 0;
ans = max(ans, temp);
}
temp = 0;
for (int i = 0; i < n; ++i) {
temp += a[i] - x;
if (temp > 0) temp = 0;
ans = max(ans, -temp);
}
return ans;
}
int ts(ld l, ld r) {
if (r - l <= (long double)(1e-11)) {
cout << setprecision(12) << f(r);
return 0;
}
ld m1 = l + (r - l) / 3;
ld m2 = r - (r - l) / 3;
ld f1 = f(m1), f2 = f(m2);
if (f1 < f2) {
ts(l, m2);
return 0;
}
if (f2 < f1) {
ts(m1, r);
return 0;
}
ts(m1, m2);
return 0;
}
int main() {
cin >> n;
ld lmax = -(long double)(10000), lmin = (long double)(10000);
for (int i = 0; i < n; ++i) {
cin >> a[i];
lmax = max(lmax, a[i]);
lmin = min(lmin, a[i]);
}
ts(lmin, lmax);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 200000 + 100;
int n;
int a[maxn], s[maxn];
double f(double x) {
double mn = 0, mx = 0;
for (int i = 0, _n = (int)(n + 1); i < _n; i++)
smin(mn, s[i] - i * x), smax(mx, s[i] - i * x);
return mx - mn;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0, _n = (int)(n); i < _n; i++) cin >> a[i];
for (int i = 0, _n = (int)(n); i < _n; i++) s[i + 1] = s[i] + a[i];
double lo = -1e5, hi = 1e5;
for (int z = 0, _n = (int)(100); z < _n; z++) {
double m1 = (2 * lo + hi) / 3;
double m2 = (lo + 2 * hi) / 3;
if (f(m1) < f(m2))
hi = m2;
else
lo = m1;
}
cout.setf(ios::fixed);
cout.precision(9);
cout << f(lo) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[200007];
int n;
double cal(double x) {
double s, maxx, minn;
maxx = a[0] - x;
s = 0;
for (int i = 0; i < n; i++) {
if (s < 0)
s = a[i] - x;
else
s = s + a[i] - x;
if (s > maxx) maxx = s;
}
minn = a[0] - x;
s = 0;
for (int i = 0; i < n; i++) {
if (s > 0)
s = a[i] - x;
else
s = s + a[i] - x;
if (s < minn) minn = s;
}
return max(fabs(maxx), fabs(minn));
}
int main() {
while (scanf("%d", &n) == 1) {
double L = 100000, R = -100000, mid, mmid, t1, t2, ans;
for (int i = 0; i < n; i++) {
scanf("%lf", a + i);
L = min(a[i], L);
R = max(a[i], R);
}
for (int i = 0; i < 200; i++) {
mid = L + (R - L) / 3;
mmid = R - (R - L) / 3;
t1 = cal(mid);
t2 = cal(mmid);
if (t1 < t2)
R = mmid, ans = t1;
else
L = mid, ans = t2;
}
printf("%.16f\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long length;
vector<double> nums;
double kadane(double x) {
double currentMax = nums[0] - x;
double currentMin = nums[0] - x;
double globalMax = nums[0] - x;
double globalMin = nums[0] - x;
for (unsigned i = 1; i < nums.size(); i++) {
currentMax = max(nums[i] - x, nums[i] - x + currentMax);
currentMin = min(nums[i] - x, nums[i] - x + currentMin);
if (currentMax > globalMax) globalMax = currentMax;
if (currentMin < globalMin) globalMin = currentMin;
}
if (abs(globalMin) < globalMax)
return globalMax;
else
return abs(globalMin);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
double num;
cin >> length;
for (int i = 0; i < length; i++) {
cin >> num;
nums.push_back(num);
}
double l = -10000, r = 10000;
double m1, m2;
double resM1, resM2;
for (int i = 0; i < 200; i++) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
resM1 = kadane(m1);
resM2 = kadane(m2);
if (resM1 < resM2)
r = m2;
else
l = m1;
}
cout << fixed << setprecision(7) << resM1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
double a[N], b[N], pr[N];
int n;
double f(double d) {
for (int i = 1; i <= n; i++) {
b[i] = a[i] - d;
pr[i] = b[i] + pr[i - 1];
}
double ans = abs(b[n]);
int mkmin = n, mkmax = n;
for (int i = n - 1; i >= 1; i--) {
if (pr[i] > pr[mkmax]) mkmax = i;
if (pr[i] < pr[mkmin]) mkmin = i;
ans = max(ans, abs(pr[mkmin] - pr[i - 1]));
ans = max(ans, abs(pr[mkmax] - pr[i - 1]));
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
double l = -1e5, r = 1e5, mid1, mid2;
for (int i = 1; i <= 300; i++) {
mid1 = (2 * l + r) / 3;
mid2 = (l + 2 * r) / 3;
if (f(mid1) > f(mid2))
l = mid1;
else
r = mid2;
}
l = (r + l) / 2;
cout << fixed << setprecision(6) << f(l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 * 2 + 10;
int arr[N], n;
double solver(double d, bool reverse) {
double ret = 0;
double curr = 0;
for (int i = 0; i < n; i++) {
curr += (arr[i] - d) * pow(-1, reverse);
if (curr < 0) curr = 0;
ret = max(ret, curr);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
double ini = -200 * 100 - 2;
double fim = 200 * 100 + 2;
int interacoes = 200;
while (interacoes--) {
double terco = (fim - ini) / 3.0;
double ter1 = ini + terco;
double ter2 = fim - terco;
double resp1 = max(solver(ter1, false), solver(ter1, true));
double resp2 = max(solver(ter2, false), solver(ter2, true));
if (resp1 < resp2) {
fim = ter2;
} else {
ini = ter1;
}
}
printf("%.10f", max(solver((ini + fim) / 2.0, false),
solver((ini + fim) / 2.0, true)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 50);
const int mod = inf + 7;
const double pi = acos(-1.0);
const double eps = 1e-10;
double mi[220000], ma[220000], u[220000];
double second[220000];
int n, a[220000];
double first(double x) {
for (int i = 1; i <= n; i++) second[i] = second[i - 1] + a[i] - x;
mi[n] = second[n];
ma[n] = second[n];
for (int i = n - 1; i >= 1; i--) {
ma[i] = max(ma[i + 1], second[i]);
mi[i] = min(mi[i + 1], second[i]);
}
double res = 0, su = 0;
for (int i = 1; i <= n; i++) {
res = max(ma[i] + su, res);
res = max(-(mi[i] + su), res);
su += -a[i] + x;
}
return res;
}
int main() {
scanf("%d", &n);
long long e = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
e += a[i];
}
double l = -(1e14);
double r = (1e14);
for (int i = 0; i <= 300; i++) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
if (first(m1) < first(m2))
r = m2;
else
l = m1;
}
printf("%.10lf", first(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[200005];
int n, k, x;
struct node {
double l, r;
};
inline node check(double v) {
double a = 0, b = 0;
double mx_a = 0, mx_b = 0;
for (int i = 1; i <= n; i++) {
a += 1.0 * (A[i] - v);
if (a < 0) a = 0;
mx_a = max(mx_a, a);
}
for (int i = 1; i <= n; i++) {
b += 1.0 * (v - A[i]);
if (b < 0) b = 0;
mx_b = max(mx_b, b);
}
return (node){mx_a, mx_b};
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
double l = -10000, r = 10000;
double ans = 0;
int num = 100;
while (num--) {
double mid = 1.0 * (l + r) / 2;
node res = check(mid);
if (res.r >= res.l) {
ans = res.r;
r = mid;
} else
l = mid;
}
printf("%lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200005], b[200005];
double l = -10001, r = 10001;
const double eps = 2e-12;
double solve(double x) {
for (int i = 1; i <= n; ++i) b[i] = a[i] - x;
double res = 0, tmp = 0;
for (int i = 1; i <= n; ++i) {
if (tmp < 0) tmp = 0;
tmp += b[i];
res = max(res, tmp);
}
tmp = 0;
for (int i = 1; i <= n; ++i) {
if (tmp < 0) tmp = 0;
tmp -= b[i];
res = max(res, tmp);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lf", &a[i]);
}
while (r > eps + l) {
double ll = (2 * l + r) / 3, rr = (l + 2 * r) / 3;
double lll = solve(ll);
double rrr = solve(rr);
if (lll < rrr)
r = rr;
else
l = ll;
}
cout << fixed << setprecision(12) << solve((l + r) / 2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200002];
pair<double, int> weakness(double x) {
double mini = 0, maxi = 0, p = 0, g = 0;
for (int i = 1; i < n + 1; i++) {
if (mini > a[i] - x * i) {
p = i;
mini = a[i] - x * i;
}
if (maxi < a[i] - x * i) {
g = i;
maxi = a[i] - x * i;
}
}
return make_pair(maxi - mini, g - p);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%d", &a[i]);
for (int i = 2; i < n + 2; i++) a[i] += a[i - 1];
double l = -1000000000, r = 1000000000;
pair<double, int> wt;
for (int i = 0; i < 80; i++) {
wt = weakness((l + r) / 2);
if (wt.second == 0) {
printf("0\n");
return 0;
}
if (wt.second > 0)
l = (l + r) / 2;
else
r = (l + r) / 2;
}
printf("%.7lf\n", wt.first);
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
void RI(int& x) {
x = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
bool flag = 1;
if (c == '-') {
flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (!flag) x = -x;
}
void RII(int& x, int& y) { RI(x), RI(y); }
void RIII(int& x, int& y, int& z) { RI(x), RI(y), RI(z); }
const int maxn = 1e5 + 1000;
const double eps = 1e-11;
int n;
int a[maxn << 1];
double b[maxn << 1];
double cal(double x) {
double res = 0;
double now = 0;
for (int i = 0; i < n; i++) b[i] = a[i] * 1.0 - x;
for (int i = 0; i < n; i++) {
now += b[i];
if (now < 0) now = 0;
res = max(res, now);
b[i] = -b[i];
}
now = 0;
for (int i = 0; i < n; i++) {
now += b[i];
if (now < 0) now = 0;
res = max(res, now);
}
return res;
}
int main() {
RI(n);
for (int i = 0; i < n; i++) RI(a[i]);
double tmp = 0;
double l = -10000, r = 10000, mid1, mid2;
double ans1, ans2;
int t = 100;
while (t--) {
mid1 = l + (r - l) / 3;
mid2 = r - (r - l) / 3;
ans1 = cal(mid1);
ans2 = cal(mid2);
if (ans1 > ans2)
l = mid1;
else
r = mid2;
}
printf("%.6f\n", cal(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n;
int a[N];
double C(double m) {
double mn = 0, mx = 0, ret = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i] - m;
ret = max(ret, max(abs(sum - mx), sum - mn));
mn = min(mn, sum);
mx = max(mx, sum);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
double lb = -10005.0, ub = 10005.0;
int t = 100;
while (t--) {
double m1 = (lb + lb + ub) / 3.0, m2 = (lb + ub + ub) / 3.0;
if (C(m1) > C(m2))
lb = m1;
else
ub = m2;
}
printf("%.10f\n", C(lb));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int inf = 1e9;
int n, a[N];
double ma(double p) {
double sum = a[1] - p, b = a[1] - p;
for (int i = 2; i <= n; i++) {
if (b > 0)
b += a[i] - p;
else
b = a[i] - p;
sum = max(sum, b);
}
return abs(sum);
}
double mi(double p) {
double sum = a[1] - p, b = a[1] - p;
for (int i = 2; i <= n; i++) {
if (b < 0)
b += a[i] - p;
else
b = a[i] - p;
sum = min(sum, b);
}
return abs(sum);
}
double work(double p) { return max(ma(p), mi(p)); }
double cal() {
double l = -10000, r = -l;
double X;
int cnt = 300;
while (cnt--) {
double mid1 = (2 * l + r) / 3.0, mid2 = (2 * r + l) / 3;
double x = work(mid1), y = work(mid2);
X = min(x, y);
if (x <= y) {
r = mid2;
} else {
l = mid1;
}
}
return X;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
printf("%.12f\n", cal());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int N;
double a[200010], b[200010], f[200010];
double calc(double x) {
memset(f, 0, sizeof(f));
for (int i = 1; i <= N; ++i) b[i] = a[i] + x;
double ans = 0, res = 0;
for (int i = 1; i <= N; ++i) {
if (res + b[i] > 0)
res += b[i];
else
res = 0;
ans = max(ans, res);
}
for (int i = 1; i <= N; ++i) b[i] = -b[i];
res = 0;
for (int i = 1; i <= N; ++i) {
if (res + b[i] > 0)
res += b[i];
else
res = 0;
ans = max(ans, res);
}
return ans;
}
int main() {
N = read();
for (int i = 1; i <= N; ++i) a[i] = read();
double l = -20000, r = 20000;
for (int cnt = 1; cnt <= 200; ++cnt) {
double mid = (l + r) / 2;
double q1 = calc(mid - eps), q2 = calc(mid + eps);
if (q1 > q2)
l = mid;
else
r = mid;
}
printf("%.7lf", calc(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int A[200000];
double T[200001];
double weakness(double x) {
T[0] = 0;
for (int i = 0; i < n; i++) {
T[i + 1] = T[i] + A[i] - x;
}
double mn = T[n], mx = T[n], mxw = 0;
for (int i = n - 1; i >= 0; i--) {
mxw = max(mxw, max(abs(mx - T[i]), abs(mn - T[i])));
if (T[i] > mx) mx = T[i];
if (T[i] < mn) mn = T[i];
}
return mxw;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
int amn = A[0], amx = A[0];
for (int i = 0; i < n; i++) {
if (amn > A[i]) amn = A[i];
if (amx < A[i]) amx = A[i];
}
double l = amn, r = amx;
for (int i = 0; i < 300; i++) {
double step = (r - l) / 3;
double m1 = weakness(l + step), m2 = weakness(r - step);
if (m1 < m2)
r -= step;
else
l += step;
}
cout << fixed << setprecision(10) << weakness(l) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[200001];
long double cum[200001];
long double EPS = 1e-12;
long double f(long double mid) {
cum[0] = arr[0] - mid;
long double mini = 0;
long double maxi = 0;
long double ans = 0;
for (int i = 0; i < n; i++) {
if (i != 0) cum[i] = (arr[i] - mid) + cum[i - 1];
ans = max(ans, abs(cum[i] - maxi));
ans = max(ans, abs(cum[i] - mini));
maxi = max(maxi, cum[i]);
mini = min(mini, cum[i]);
}
return ans;
}
long double ternarySearch(long double left, long double right) {
while (right - left > EPS) {
long double g = left + (right - left) / 3,
h = left + 2 * (right - left) / 3;
if (f(g) < f(h))
right = h;
else
left = g;
}
return f((left + right) / 2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
cout << fixed << setprecision(10) << ternarySearch(-10000, 10000) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200100], b[200100];
const double eps = 1e-6;
double getmax() {
double ans = 0, sum = 0;
for (int i = 1; i <= n; i++) {
sum = sum + b[i];
if (sum < 0) sum = 0;
ans = max(ans, sum);
}
return ans;
}
double calc(double x) {
for (int i = 1; i <= n; i++) b[i] = a[i] - x;
double ans = getmax();
for (int i = 1; i <= n; i++) b[i] = -b[i];
ans = max(ans, getmax());
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf", &a[i]);
double l = -10000.0, r = 10000.0, mid;
for (int i = 0; i < 100; i++) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
if (calc(m1) < calc(m2))
r = m2;
else
l = m1;
}
printf("%.6f\n", calc(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double getMax(double *arr, double x) {
for (int i = 0; i < n; i++) arr[i] -= x;
double cur = arr[0], maxm = arr[0];
bool flag = false;
for (int i = 0; i < n; i++) {
if (arr[i] >= 0) {
flag = true;
}
cur = max(arr[i], maxm);
}
if (!flag) {
for (int i = 0; i < n; i++) arr[i] += x;
return maxm;
}
cur = 0, maxm = arr[0];
for (int i = 0; i < n; i++) {
cur += arr[i];
if (cur < 0) cur = 0;
maxm = max(cur, maxm);
}
for (int i = 0; i < n; i++) arr[i] += x;
return maxm;
}
double getMin(double *arr, double x) {
for (int i = 0; i < n; i++) arr[i] -= x;
double cur = arr[0], minm = arr[0];
bool flag = false;
for (int i = 0; i < n; i++) {
if (arr[i] <= 0) {
flag = true;
}
cur = min(cur, minm);
}
if (!flag) {
for (int i = 0; i < n; i++) arr[i] += x;
return minm;
}
cur = 0, minm = arr[0];
for (int i = 0; i < n; i++) {
cur += arr[i];
if (cur > 0) cur = 0;
minm = min(cur, minm);
}
for (int i = 0; i < n; i++) arr[i] += x;
return minm;
}
double search(double *arr) {
double lo = *min_element(arr, arr + n);
double hi = *max_element(arr, arr + n);
double brr[200200];
for (int i = 0; i < n; i++) brr[i] = arr[i];
int t = 200;
while (t--) {
double mid = (lo + hi) / 2;
double maxmp = abs(getMax(brr, mid));
double maxmn = abs(getMin(brr, mid));
if (maxmp > maxmn)
lo = mid;
else
hi = mid;
}
return (lo + hi) / 2;
}
int main() {
double arr[200002];
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lf", &arr[i]);
}
double x = search(arr);
double ans1 = abs(getMax(arr, x));
double ans2 = abs(getMin(arr, x));
printf("%.12lf\n", max(ans1, ans2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int n;
double calc(double x) {
double ans1 = 0, sum1 = 0;
for (int i = 1; i <= n; i++) {
if (sum1 > 0)
sum1 += a[i] - x;
else
sum1 = a[i] - x;
ans1 = max(ans1, sum1);
}
double ans2 = 0, sum2 = 0;
for (int i = 1; i <= n; i++) {
if (sum2 < 0)
sum2 += a[i] - x;
else
sum2 = a[i] - x;
ans2 = min(ans2, sum2);
}
return max(ans1, abs(ans2));
}
int main() {
int maxval = 0, minval = 20000;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
maxval = max(maxval, a[i]);
minval = min(minval, a[i]);
}
double l = minval, r = maxval, mid1, mid2;
for (int times = 0; times < 100; times++) {
mid1 = (2 * l + r) / 3;
mid2 = (l + 2 * r) / 3;
if (calc(mid1) < calc(mid2))
r = mid2;
else
l = mid1;
}
printf("%.7lf\n", calc(mid1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 8;
int n;
double a[N], q, w, ans, x, l = -N, r = N, m1, m2, mn, mx, sum;
double c(double x) {
mx = 0, mn = 0, ans = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += (a[i] - x);
ans = max(ans, max(abs(sum - mx), abs(sum - mn)));
mn = min(mn, sum);
mx = max(mx, sum);
}
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < 500; i++) {
m1 = l + (r - l) / 3;
m2 = l + (r - l) * 2 / 3;
if (c(m1) > c(m2))
l = m1;
else
r = m2;
}
cout << fixed << setprecision(15) << c(l);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-11;
int n;
int a[200010];
double b[200010];
double l = -20000, r = 20000, ans = 2147483647, w1, w2, v1, v2;
double make(double x) {
double maxh = -2147483647, tmp = 0, minh = 2147483647;
for (int i = 1; i <= n; i++) b[i] = a[i] - x;
for (int i = 1; i <= n; i++) {
if (tmp < 0)
tmp = b[i];
else
tmp += b[i];
if (tmp > maxh) maxh = tmp;
}
tmp = 0;
for (int i = 1; i <= n; i++) {
if (tmp > 0)
tmp = b[i];
else
tmp += b[i];
if (tmp < minh) minh = tmp;
}
return max(maxh, -minh);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= 200; i++) {
w1 = l + (r - l) / 3;
w2 = r - (r - l) / 3;
v1 = make(w1);
v2 = make(w2);
if (v1 < v2)
r = w2, ans = min(ans, v1);
else
l = w1, ans = min(ans, v2);
}
printf("%.15lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double ans = 0;
double x = 0;
int n;
vector<double> v;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
double ans = 0.00000000;
double L = -100005, R = -L;
for (int roda = 0; roda <= 90; roda++) {
double mid = (L + R) / 2.000;
double mxans = 0.0000000000000, mnans = 0.00000000000;
double lxans = 0.000000000000, lyans = 0.00000000000;
double sj = 0.00;
for (int i = 1; i <= n; i++) {
sj += v[i] - mid;
double lans = sj, rans = sj;
lans = sj - mxans;
rans = sj - mnans;
if (i == 1) {
lxans = sj;
lyans = sj;
mxans = sj;
mnans = sj;
} else {
lxans = min(lxans, lans);
lyans = max(lyans, rans);
lxans = min(lxans, sj);
lyans = max(lyans, sj);
mxans = max(mxans, sj);
mnans = min(mnans, sj);
}
}
if (-lxans > lyans) {
R = mid;
} else
L = mid;
}
double mid = (L + R) / 2.000;
double mxans = 0.0000000000000, mnans = 0.00000000000;
double lxans = 0.000000000000, lyans = 0.00000000000;
double sj = 0.00;
for (int i = 1; i <= n; i++) {
sj += v[i] - mid;
double lans = sj, rans = sj;
lans = sj - mxans;
rans = sj - mnans;
if (i == 1) {
lxans = sj;
lyans = sj;
mxans = sj;
mnans = sj;
} else {
lxans = min(lxans, lans);
lyans = max(lyans, rans);
lxans = min(lxans, sj);
lyans = max(lyans, sj);
mxans = max(mxans, sj);
mnans = min(mnans, sj);
}
}
ans = max(fabs(lyans), fabs(lxans));
cout << fixed << setprecision(9) << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
double find_max(int *a, int n, double x) {
double min_p = a[0] - x;
double max_p = a[0] - x;
double maxv = abs(a[0] - x);
for (int i = 1; i < n; ++i) {
min_p = min(min_p + a[i] - x, a[i] - x);
max_p = max(max_p + a[i] - x, a[i] - x);
maxv = max(abs(min_p), maxv);
maxv = max(abs(max_p), maxv);
}
return maxv;
}
int main() {
ios_base::sync_with_stdio(false);
int a[200000];
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
double L = -1e9;
double R = 1e9 + 1e-2;
while (abs(L - R) > 1e-11) {
double x1 = L + (R - L) * 1 / 3;
double x2 = L + (R - L) * 2 / 3;
double vl = find_max(a, n, x1);
double vr = find_max(a, n, x2);
if (vl + 1e-9 < vr) {
R = x2;
} else {
L = x1;
}
}
std::cout.precision(8);
cout << fixed << find_max(a, n, L) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using ulli = unsigned long long int;
using ld = long double;
int n;
ld a[(int)(2e5 + 5)];
ld f(ld x) {
ld ans = 0;
ld temp = 0;
for (int i = 0; i < n; ++i) {
temp += a[i] - x;
if (temp < 0) temp = 0;
ans = max(ans, temp);
}
temp = 0;
for (int i = 0; i < n; ++i) {
temp += a[i] - x;
if (temp > 0) temp = 0;
ans = max(ans, -temp);
}
return ans;
}
int ts(ld l, ld r) {
if (r - l <= (long double)(1e-12)) {
cout << setprecision(12) << f(r);
return 0;
}
ld m1 = l + (r - l) / 3;
ld m2 = r - (r - l) / 3;
ld f1 = f(m1), f2 = f(m2);
if (f1 < f2) {
ts(l, m2);
return 0;
}
if (f2 < f1) {
ts(m1, r);
return 0;
}
ts(m1, m2);
return 0;
}
int main() {
cin >> n;
ld lmax = -(long double)(10000), lmin = (long double)(10000);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
ts(-(long double)(10000), (long double)(10000));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int INF = 2000000010;
const long long INFLL = 999999999999999999ll;
const double eps = 1e-11;
int origin[MAXN];
double cop[MAXN];
int n;
double f(double x) {
for (int i = 1; i <= n; i++) cop[i] = 1.0 * origin[i] - x;
double maxx = 0;
double cur = 0;
for (int i = 1; i <= n; i++) {
cur = max(0.0, cur + cop[i]);
maxx = max(maxx, cur);
}
double ret = maxx;
maxx = 0;
for (int i = 1; i <= n; i++) cop[i] *= -1;
cur = 0;
for (int i = 1; i <= n; i++) {
cur = max(0.0, cur + cop[i]);
maxx = max(maxx, cur);
}
return max(ret, maxx);
}
double ternary(double left, double right) {
if (right - left < eps) return (left + right) / 2.0;
double leftThird = (2.0 * left + right) / 3.0;
double rightThird = (left + 2.0 * right) / 3.0;
if (f(leftThird) > f(rightThird))
return ternary(leftThird, right);
else
return ternary(left, rightThird);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &origin[i]);
printf("%lf\n", f(ternary(-20000.0, 20000.0)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
double fmin(double x, int n) {
double ans = 0, cur = 0;
for (int i = 0; i < n; i++) {
cur += (a[i] - x);
if (cur > 0) cur = 0;
ans = min(ans, cur);
}
return ((ans) > 0 ? (ans) : (-(ans)));
}
double fmax(double x, int n) {
double ans = 0, cur = 0;
for (int i = 0; i < n; i++) {
cur += (a[i] - x);
if (cur < 0) cur = 0;
ans = max(ans, cur);
}
return ((ans) > 0 ? (ans) : (-(ans)));
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double lo = -10000, hi = 10000, mid, v1 = -200, v2 = 200;
while (((v1 - v2) > 0 ? (v1 - v2) : (-(v1 - v2))) > .4 * 1e-6) {
mid = (lo + hi) / 2;
v1 = fmin(mid, n);
v2 = fmax(mid, n);
if (v1 < v2)
lo = mid;
else
hi = mid;
}
printf("%.9lf\n", v1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N], n;
double f(double x) {
double sum = 0, mn = 0, mx = 0, ans = 0;
for (int i = 0; i < n; i++) {
mn = min(mn, sum);
mx = max(mx, sum);
sum += a[i] - x;
ans = max(ans, abs(sum - mn));
ans = max(ans, abs(sum - mx));
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
double l = -1e4 - 7, r = 1e4 + 7;
int t = 230;
while (t--) {
double mid1 = (2 * r + l) / 3;
double mid2 = (2 * l + r) / 3;
if (f(mid1) < f(mid2))
l = mid2;
else
r = mid1;
}
cout << setprecision(9) << fixed << f(l) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[(int)2e5 + 10];
long double WeekNess, mx = -1e18, mn = 1e18, sum;
long double Answer(long double Check) {
mx = 0, mn = 0, sum = 0, WeekNess = 0;
for (int i = 0; i < n; i++) {
mx = max(mx, sum);
mn = min(mn, sum);
sum += a[i] - Check;
WeekNess = max(WeekNess, fabs(sum - mx));
WeekNess = max(WeekNess, fabs(sum - mn));
}
return WeekNess;
}
long double BinarySol(long double l, long double r) {
long double mid1 = (2 * l + r) / 3;
long double mid2 = (2 * r + l) / 3;
int c = 0;
while (c++ <= 200) {
mid1 = (2 * l + r) / 3;
mid2 = (2 * r + l) / 3;
if (Answer(mid1) >= Answer(mid2)) {
l = mid1;
} else {
r = mid2;
}
}
return l;
}
int main() {
cin >> n;
for (int i = 0; i < n && scanf("%d", a + i); i++)
;
cout << setprecision(6) << fixed << Answer(BinarySol(-1e10, 1e10));
}
|
#include <bits/stdc++.h>
using namespace std;
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << h;
if (sizeof...(t)) {
cerr << ", ";
}
DBG(t...);
}
int n;
long double a[200005];
inline long double weakness(long double x) {
long double s1 = 0.0, s2 = 0.0;
long double mx = 0.0;
for (int i = 0; i < n; i++) {
long double temp = a[i] - x;
s1 += temp;
if (s1 < 0) s1 = 0;
s2 += temp;
if (s2 > 0) s2 = 0;
mx = max(mx, max(s1, -s2));
}
return mx;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long double l = -10001.0, r = 10001.0;
while (r - l > 1e-12) {
long double lm = (l * 2 + r) / 3;
long double rm = (l + r * 2) / 3;
if (weakness(lm) > weakness(rm))
l = lm;
else
r = rm;
}
cout << setprecision(9) << weakness(l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn];
double b[maxn];
int n;
double maxsum(double a[maxn]) {
double mx = 0, now = 0;
for (int i = 1; i <= n; ++i) {
now += a[i];
if (now > mx) mx = now;
if (now < 0) {
now = 0;
}
}
return mx;
}
double f(double x) {
for (int i = 1; i <= n; ++i) {
b[i] = a[i] - x;
}
double psum = maxsum(b);
for (int i = 1; i <= n; ++i) {
b[i] *= -1;
}
double nsum = maxsum(b);
return max(psum, nsum);
}
double ts(double l, double r) {
for (int i = 1; i <= 300; ++i) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
double f1 = f(m1);
double f2 = f(m2);
if (f1 > f2) {
l = m1;
} else {
r = m2;
}
}
return f(l);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
double l = *min_element(a + 1, a + n + 1);
double r = *max_element(a + 1, a + n + 1);
cout << fixed << setprecision(12) << ts(l, r) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int n;
double a[200005];
double f(double x) {
int i;
double sum[200005] = {0}, max = 0, min = 0;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i - 1] - x;
if (max < sum[i]) max = sum[i];
if (min > sum[i]) min = sum[i];
}
return max - min;
}
int main() {
int i;
double l = -1e9, m, mm, r = 1e9;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lf", &a[i]);
for (i = 0; i < 200; i++) {
m = l + (r - l) / 3;
mm = r - (r - l) / 3;
if (f(m) < f(mm))
r = mm;
else
l = m;
}
printf("%.15f\n", f(l));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
const double inf = 1e30;
struct point {
int x, y;
point() : x(0), y(0) {}
point(int x_, int y_) : x(x_), y(y_) {}
double get_b(double k) { return y - k * x; }
} a[maxn], b[maxn];
double get_k(point a, point b) { return 1.0 * (b.y - a.y) / (b.x - a.x); }
long long det(point a, point b) { return 1LL * a.x * b.y - 1LL * a.y * b.x; }
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
int n, an, bn;
int main() {
scanf("%d", &n);
an = bn = 0, a[1] = b[1] = point(0, 0);
for (int i = 1, v, s = 0; i <= n; ++i)
scanf("%d", &v), a[i + 1] = b[i + 1] = point(i, s += v);
for (int i = 1; i <= n + 1; ++i) {
while (an >= 2 && det(a[an] - a[an - 1], a[i] - a[an - 1]) <= 0) --an;
while (bn >= 2 && det(b[bn] - b[bn - 1], b[i] - b[bn - 1]) >= 0) --bn;
a[++an] = a[i], b[++bn] = b[i];
}
double ans = inf, k1, k2;
for (int i = 1, j = bn; i < an || j > 1;) {
if (i < an)
k1 = get_k(a[i], a[i + 1]);
else
k1 = inf;
if (j > 1)
k2 = get_k(b[j], b[j - 1]);
else
k2 = inf;
if (k1 < k2)
ans = min(ans, b[j].get_b(k1) - a[i++].get_b(k1));
else
ans = min(ans, b[j--].get_b(k2) - a[i].get_b(k2));
}
printf("%.12f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[200005], ans;
int i, j, k, s, m, n;
inline double check(double o) {
double ans1 = 0, ans2 = 0, ans = 0;
for (int i = 1; i <= n; i++) {
ans1 = ans1 + a[i] - o;
ans2 = ans2 + a[i] - o;
if (ans1 > 0) ans1 = 0;
if (ans2 < 0) ans2 = 0;
ans = max(ans, max(abs(ans1), abs(ans2)));
}
return ans;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%lf", &a[i]);
ans = n * 10000.0;
double l = -10000.0, r = 10000.0;
while (l + 1e-12 <= r) {
double mid = (r - l) / 3.0 + l, mid1 = r - (r - l) / 3.0;
double gt = check(mid), gtw = check(mid1);
if (gt < gtw) {
ans = min(ans, gt);
r = mid1 - 1e-12;
} else {
ans = min(ans, gtw);
l = mid + 1e-12;
}
}
printf("%.9lf", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
double a[N];
int n, m, i, j, k;
double l, r, f1, f2, u, v;
double solve(double c) {
int i;
double sum, ans, l, r;
l = r = sum = 0;
for (i = 1; i <= n; i++) {
sum += a[i] - c;
l = min(l, sum);
r = max(r, sum);
}
return r - l;
}
int main() {
scanf("%d", &n);
l = 1e8;
r = -1e8;
for (i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
r = max(r, a[i]);
l = min(l, a[i]);
}
while (1) {
u = l + (r - l) / 3;
v = l + (r - l) / 3 * 2;
f1 = solve(u);
f2 = solve(v);
if (fabs(f1 - f2) <= 1e-8 && fabs(r - l) <= 1e-11) break;
if (f1 <= f2)
r = v;
else
l = u;
}
printf("%.9lf\n", f1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double pref[200500];
int a[200500], n;
long double maxx(long double x) {
pref[0] = 1.0 * a[0] - x;
for (int i = 1; i < n; ++i) {
pref[i] = pref[i - 1] + (1.0 * a[i] - x);
}
double mn = 0, mx = 0, res = 0;
for (int i = 0; i < n; ++i) {
if (fabs(pref[i] - mn) > res) res = fabs(pref[i] - mn);
if (pref[i] < mn) mn = pref[i];
if (fabs(pref[i] - mx) > res) res = fabs(pref[i] - mx);
if (pref[i] > mx) mx = pref[i];
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long double l = -100000, r = 100000;
while (r - l > 0.000000000001) {
long double m1 = l + (r - l) / 3.0;
long double m2 = r - (r - l) / 3.0;
if (maxx(m1) > maxx(m2))
l = m1;
else
r = m2;
}
cout << fixed << setprecision(9);
cout << maxx(l) << '\n';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.