QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#685948 | #7310. Circular Sectors | crimson231 | AC ✓ | 93ms | 8764kb | C++23 | 13.0kb | 2024-10-28 22:07:50 | 2024-10-28 22:07:52 |
Judging History
answer
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cassert>
#include <vector>
typedef long long ll;
typedef double ld;
typedef std::vector<ld> Vld;
const ld INF = 1e17;
const ld TOL = 1e-13;
const ld PI = acosl(-1);
const int LEN = 505;
inline int sign(const ll& x) { return x < 0 ? -1 : !!x; }
inline int sign(const ld& x) { return x < -TOL ? -1 : x > TOL; }
inline bool zero(const ld& x) { return !sign(x); }
inline bool eq(const ld& u, const ld& v) { return zero(u - v); }
inline ll sq(const ll& x) { return x * x; }
inline ld norm(ld th) { while (th < 0) th += 2 * PI; while (sign(th - 2 * PI) >= 0) th -= 2 * PI; return th; }
inline ld fit(const ld& x, const ld& lo, const ld& hi) { return std::min(hi, std::max(lo, x)); }
#define si lo
#define theta hi
#define LO x
#define HI y
#define LINE 1
#define CIRCLE 2
#define STRONG 0
#define WEAK 1
int N;
struct Pos {
ld x, y;
Pos(ld x_ = 0, ld y_ = 0) : x(x_), y(y_) {}
bool operator == (const Pos& p) const { return zero(x - p.x) && zero(y - p.y); }
bool operator < (const Pos& p) const { return zero(x - p.x) ? y < p.y : x < p.x; }
Pos operator + (const Pos& p) const { return { x + p.x, y + p.y }; }
Pos operator - (const Pos& p) const { return { x - p.x, y - p.y }; }
Pos operator * (const ld& scalar) const { return { x * scalar, y * scalar }; }
Pos operator / (const ld& scalar) const { return { x / scalar, y / scalar }; }
ld operator * (const Pos& p) const { return x * p.x + y * p.y; }
ld operator / (const Pos& p) const { return x * p.y - y * p.x; }
Pos rot(ld the) const { return Pos(x * cos(the) - y * sin(the), x * sin(the) + y * cos(the)); }
ld Euc() const { return x * x + y * y; }
ld mag() const { return sqrt(Euc()); }
ld rad() const { return norm(atan2(y, x)); }
inline friend std::istream& operator >> (std::istream& is, Pos& p) { is >> p.x >> p.y; return is; }
inline friend std::ostream& operator << (std::ostream& os, const Pos& p) { os << p.x << " " << p.y; return os; }
};
typedef std::vector<Pos> Polygon;
ld cross(const Pos& d1, const Pos& d2, const Pos& d3) { return (d2 - d1) / (d3 - d2); }
int ccw(const Pos& d1, const Pos& d2, const Pos& d3) { return sign(cross(d1, d2, d3)); }
ld dot(const Pos& d1, const Pos& d2, const Pos& d3) { return (d2 - d1) * (d3 - d2); }
ld dot(const Pos& d1, const Pos& d2, const Pos& d3, const Pos& d4) { return (d2 - d1) * (d4 - d3); }
bool on_seg_strong(const Pos& d1, const Pos& d2, const Pos& d3) { return !ccw(d1, d2, d3) && sign(dot(d1, d3, d2)) >= 0; }
bool on_seg_weak(const Pos& d1, const Pos& d2, const Pos& d3) { return !ccw(d1, d2, d3) && sign(dot(d1, d3, d2)) > 0; }
bool collinear(const Pos& d1, const Pos& d2, const Pos& d3, const Pos& d4) { return !ccw(d1, d2, d3) && !ccw(d1, d2, d4); }
ld projection(const Pos& d1, const Pos& d2, const Pos& d3) { return dot(d1, d2, d3) / (d1 - d2).mag(); }
bool inside(const Pos& p0, const Pos& p1, const Pos& p2, const Pos& q, const int& f = STRONG) {
if (ccw(p0, p1, p2) < 0) return ccw(p0, p1, q) >= f || ccw(p1, p2, q) >= f;
return ccw(p0, p1, q) >= f && ccw(p1, p2, q) >= f;
}
Pos intersection(const Pos& p1, const Pos& p2, const Pos& q1, const Pos& q2) { ld a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2); return (p1 * a2 + p2 * a1) / (a1 + a2); }
struct Seg {
Pos s, e;
Seg(Pos s_ = Pos(), Pos e_ = Pos()) : s(s_), e(e_) {}
Pos p(const ld& rt) const { return s + (e - s) * rt; }
ld green(const ld& lo, const ld& hi) const {
ld d = hi - lo;
ld ratio = (lo + hi) * .5;
Pos m = p(ratio);
return m.y * d * (s.x - e.x);
}
};
ld dot(const Seg& p, const Seg& q) { return dot(p.s, p.e, q.s, q.e); }
bool collinear(const Seg& p, const Seg& q) { return collinear(p.s, p.e, q.s, q.e); }
struct Circle {
Pos c;
int r;
Circle(Pos c_ = Pos(), int r_ = 0) : c(c_), r(r_) {}
bool operator == (const Circle& q) const { return c == q.c && r == q.r; }
bool operator < (const Circle& q) const { return c == q.c ? r < q.r : c < q.c; }
bool operator < (const Pos& p) const { return sign(r - (c - p).mag()) < 0; }
bool outside(const Circle& q) const { return sign((c - q.c).Euc() - sq((ll)r + q.r)) >= 0; }
Pos p(const ld& t) const { return c + Pos(r, 0).rot(t); }
ld rad(const Pos& p) const { return (p - c).rad(); }
ld area(const ld& lo, const ld& hi) const { return (hi - lo) * r * r * .5; }
ld green(const ld& lo, const ld& hi) const {
Pos s = Pos(cos(lo), sin(lo)), e = Pos(cos(hi), sin(hi));
ld fan = area(lo, hi);
Pos m = c + (s + e) * r * (ld).5;
ld tz = (cos(lo) - cos(hi)) * m.y * r;
return fan + tz - (s / e) * r * r * (ld).5;
}
inline friend std::istream& operator >> (std::istream& is, Circle& c) { is >> c.c >> c.r; return is; }
inline friend std::ostream& operator << (std::ostream& os, const Circle& c) { os << c.c << " " << c.r; return os; }
};
ld intersection(const Seg& s1, const Seg& s2) {
const Pos& p1 = s1.s, p2 = s1.e, q1 = s2.s, q2 = s2.e;
ld det = (q2 - q1) / (p2 - p1);
if (zero(det)) return -1;
ld a1 = ((q2 - q1) / (q1 - p1)) / det;
ld a2 = ((p2 - p1) / (p1 - q1)) / -det;
if (0 < a1 && a1 < 1 && -TOL < a2 && a2 < 1 + TOL) return a1;
return -1;
}
Vld circle_line_intersections(const Seg& l, const Circle& q, const int& t = LINE) {
//https://math.stackexchange.com/questions/311921/get-location-of-vector-circle-intersection
Pos s = l.s, e = l.e;
Pos vec = e - s;
Pos OM = s - q.c;
ld a = vec.Euc();
ld b = vec * OM;
ld c = OM.Euc() - q.r * q.r;
ld J = b * b - a * c;
if (J < -TOL) return {};
ld det = sqrt(std::max((ld)0, J));
ld lo = (-b - det) / a;
ld hi = (-b + det) / a;
Vld ret;
if (t == LINE) {
if (0 < lo && lo < 1) ret.push_back(lo);
if (zero(det)) return ret;
if (0 < hi && hi < 1) ret.push_back(hi);
}
else {//circle
auto the = [&](ld rt) { return q.rad(s + (e - s) * rt); };
if (-TOL < lo && lo < 1 + TOL) ret.push_back(the(lo));
if (zero(det)) return ret;
if (-TOL < hi && hi < 1 + TOL) ret.push_back(the(hi));
}
return ret;
}
Vld intersection(const Circle& a, const Circle& b) {
Pos ca = a.c, cb = b.c;
Pos vec = cb - ca;
ll ra = a.r, rb = b.r;
ld distance = vec.mag();
ld rd = vec.rad();
if (vec.Euc() > sq(ra + rb) + TOL) return {};
if (vec.Euc() < sq(ra - rb) - TOL) return {};
ld X = (ra * ra - rb * rb + vec.Euc()) / (2 * distance * ra);
if (X < -1) X = -1;
if (X > 1) X = 1;
ld h = acos(X);
Vld ret = {};
ret.push_back(norm(rd - h));
if (zero(h)) return ret;
ret.push_back(norm(rd + h));
return ret;
}
struct Arc {
ld lo, hi;
Arc(ld l_ = 0, ld h_ = 0) : lo(l_), hi(h_) {}
bool operator < (const Arc& a) const { return zero(lo - a.lo) ? hi < a.hi : lo < a.lo; }
inline friend std::istream& operator >> (std::istream& is, Arc& a) { is >> a.lo >> a.hi; return is; }
inline friend std::ostream& operator << (std::ostream& os, const Arc& a) { os << a.lo << " " << a.hi; return os; }
};
typedef std::vector<Arc> Arcs;
struct Sector {
Circle c;
Arc a;
Seg s1, s2;
Arcs va;
Polygon v1, v2;
int val = -1;
inline friend std::istream& operator >> (std::istream& is, Sector& s) { is >> s.c >> s.a; return is; }
void init() {
a.hi = norm(a.si + a.theta);
std::swap(a.lo, a.hi);
Pos lo = c.p(a.lo), hi = c.p(a.hi);
s1 = Seg(lo, c.c); s2 = Seg(c.c, hi);//ccw
va.clear(); v1.clear(); v2.clear();
val = 1;
}
bool outer_check(const Pos& q, const int& f = STRONG) const { return inside(s2.e, c.c, s1.s, q, f); }
} S[LEN];
bool inner_check(const Sector& s, const Pos& p, const int& f = STRONG) { return (s.c < p) ? 0 : !s.outer_check(p, (f + 1) % 2); }
void init() {
std::sort(S, S + N, [&](const Sector& p, const Sector& q) -> bool { return p.c < q.c; });
for (int i = 0; i < N; i++) {
const Arc& ai = S[i].a;
Arcs uva;
for (int j = 0; j < N; j++) {
if (i == j) continue;
const Circle& ci = S[i].c, cj = S[j].c;
if (ci.outside(cj)) continue;
const Arc& aj = S[j].a;
const Seg& is1 = S[i].s1, is2 = S[i].s2;
const Seg& js1 = S[j].s1, js2 = S[j].s2;
if (ci == cj) {
if (j < i) continue;
while (j < N && ci == S[j].c) {
S[j].val = 0;
uva.push_back(S[j].a);
if (!S[i].outer_check(js1.s, WEAK))
S[j].v1.push_back(Pos(0, 1));
if (!S[i].outer_check(js2.e, WEAK))
S[j].v2.push_back(Pos(0, 1));
if (!S[j].outer_check(is1.s, STRONG) || is1.s == js2.e)
S[i].v1.push_back(Pos(0, 1));
if (!S[j].outer_check(is2.e, STRONG) || is2.e == js1.s)
S[i].v2.push_back(Pos(0, 1));
j++;
}
j--;
if (S[i].val) {
S[i].val = 2;
uva.push_back(S[i].a);
}
continue;
}
Vld tmp = { (ld)0, 2 * PI };
if (S[i].val) {
Vld cc = intersection(ci, cj);
Vld cs1 = circle_line_intersections(js1, ci, CIRCLE);
Vld cs2 = circle_line_intersections(js2, ci, CIRCLE);
tmp.insert(tmp.end(), cc.begin(), cc.end());
tmp.insert(tmp.end(), cs1.begin(), cs1.end());
tmp.insert(tmp.end(), cs2.begin(), cs2.end());
std::sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end(), eq), tmp.end());
int sz = tmp.size();
for (int k = 0; k < sz - 1; k++) {
ld l = tmp[k], h = tmp[k + 1];
ld m = (l + h) * .5;
Pos mid = ci.p(m);
if (inner_check(S[j], mid)) S[i].va.push_back(Arc(l, h));
}
}
if (i < j) {
ld r1, r2, r3, r4;
std::vector<Seg> IS = { is1, is2 };
std::vector<Seg> JS = { js1, js2 };
for (int k = 1; k <= 2; k++) {
for (int l = 1; l <= 2; l++) {
const Seg& s1 = IS[k - 1];
const Seg& s2 = JS[l - 1];
if (collinear(s1, s2)) {
r1 = projection(s1.s, s1.e, s2.s); r1 = fit(r1, 0, 1);
r2 = projection(s1.s, s1.e, s2.e); r2 = fit(r2, 0, 1);
r3 = projection(s2.s, s2.e, s1.s); r3 = fit(r3, 0, 1);
r4 = projection(s2.s, s2.e, s1.e); r4 = fit(r4, 0, 1);
if (l == 1) S[j].v1.push_back(Pos(r3, r4));
if (l == 2) S[j].v2.push_back(Pos(r3, r4));
if (dot(s1, s2) < 0) {
if (k == 1) S[i].v1.push_back(Pos(r1, r2));
if (k == 2) S[i].v2.push_back(Pos(r1, r2));
}
}
}
}
}
for (int t = 1; t <= 2; t++) {
tmp = { (ld)0, (ld)1 };
Vld ix1;
Seg s = t == 1 ? is1 : is2;
if (on_seg_weak(s.s, s.e, cj.c)) tmp.push_back(projection(s.s, s.e, cj.c));
if (on_seg_weak(s.s, s.e, S[j].s1.s)) tmp.push_back(projection(s.s, s.e, S[j].s1.s));
if (on_seg_weak(s.s, s.e, S[j].s2.e)) tmp.push_back(projection(s.s, s.e, S[j].s2.e));
ix1 = circle_line_intersections(s, cj, LINE);
ld ix2 = intersection(s, js1);
ld ix3 = intersection(s, js2);
tmp.insert(tmp.end(), ix1.begin(), ix1.end());
if (ix2 > -TOL) tmp.push_back(ix2);
if (ix3 > -TOL) tmp.push_back(ix3);
std::sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end(), eq), tmp.end());
int sz = tmp.size();
for (int k = 0; k < sz - 1; k++) {
ld l = tmp[k], h = tmp[k + 1];
ld m = (l + h) * .5;
Pos mid = s.p(m);
if (t == 1 && inner_check(S[j], mid, WEAK)) S[i].v1.push_back(Pos(l, h));
if (t == 2 && inner_check(S[j], mid, WEAK)) S[i].v2.push_back(Pos(l, h));
}
}
}
if (S[i].val == 1) {
ld lo = ai.lo, hi = ai.hi;
if (lo > hi) {
S[i].va.push_back(Arc(lo, 2 * PI));
S[i].va.push_back(Arc(0, hi));
}
else S[i].va.push_back(Arc(lo, hi));
}
else if (S[i].val == 2) {
Arcs va;
for (const Arc& a : uva) {
ld lo = a.lo, hi = a.hi;
if (lo < hi) {
va.push_back(Arc(hi, 2 * PI));
va.push_back(Arc(0, lo));
}
else va.push_back(Arc(hi, lo));
}
std::sort(va.begin(), va.end());
va.push_back(Arc(2 * PI, 2 * PI));
ld cur = 0;
for (const Arc& a : va) {
if (a.lo > cur) S[i].va.push_back(Arc(cur, a.lo)), cur = a.hi;
else cur = std::max(cur, a.hi);
}
}
std::sort(S[i].va.begin(), S[i].va.end()); S[i].va.push_back(Arc(2 * PI, 2 * PI));
std::sort(S[i].v1.begin(), S[i].v1.end()); S[i].v1.push_back(Pos(1, 1));
std::sort(S[i].v2.begin(), S[i].v2.end()); S[i].v2.push_back(Pos(1, 1));
}
return;
}
ld union_area() {
ld A = 0, hi = 0;
for (int i = 0; i < N; i++) {
if (S[i].val) {
hi = 0;
for (const Arc& a : S[i].va) {
if (a.lo > hi) A += S[i].c.green(hi, a.lo), hi = a.hi;
else hi = std::max(hi, a.hi);
}
}
if (!eq(S[i].s1.s.x, S[i].s1.e.x)) {
hi = 0;
for (const Pos& a : S[i].v1) {
if (a.LO > hi) A += S[i].s1.green(hi, a.LO), hi = a.HI;
else hi = std::max(hi, a.HI);
}
}
if (!eq(S[i].s2.s.x, S[i].s2.e.x)) {
hi = 0;
for (const Pos& a : S[i].v2) {
if (a.LO > hi) A += S[i].s2.green(hi, a.LO), hi = a.HI;
else hi = std::max(hi, a.HI);
}
}
}
return A;
}
void query() {
for (int i = 0; i < N; i++) { std::cin >> S[i]; S[i].init(); }
init();
std::cout << union_area() << "\n";
return;
}
void solve() {
std::cin.tie(0)->sync_with_stdio(0);
std::cout.tie(0);
std::cout << std::fixed;
std::cout.precision(15);
while (std::cin >> N) query();
return;
}
int main() { solve(); return 0; }//boj19368 Circular Sectors
//Petrozavodsk Programming Camp > Winter 2017 > Day 2: Xiaoxu Guo Contest J
这程序好像有点Bug,我给组数据试试?
详细
Test #1:
score: 100
Accepted
time: 1ms
memory: 4412kb
input:
2 -3 -5 5 0.705 0.217 -5 1 4 3.070 4.136 1 -4 -4 1 0.485 2.260 3 4 4 4 4.266 4.673 2 -4 5 0.353 5.565 -2 1 3 3.974 0.207
output:
35.800500000000007 1.130000000000000 106.444931438703591
result:
ok 3 numbers
Test #2:
score: 0
Accepted
time: 1ms
memory: 4512kb
input:
2 -2 -1 5 2.250 0.555 -3 0 2 2.189 0.788 2 -5 1 5 0.432 1.643 3 5 5 4.779 2.014 2 2 0 3 4.194 2.691 4 -3 4 0.998 5.376 2 -3 1 4 5.841 2.968 -4 -3 2 4.151 4.029 2 4 -1 5 2.416 2.385 5 0 3 5.315 2.683 2 -2 0 2 3.972 1.255 2 -5 2 0.912 5.211 2 1 0 4 2.826 3.794 -2 -3 1 3.335 3.836 2 -5 4 2 2.496 2.273 ...
output:
6.937500000000002 45.712500000000006 43.533920893527551 31.802000000000010 41.885999999999996 12.932000000000002 31.713102368390356 9.889999999999999 3.811500000000000 26.789999999999999 37.187500000000007 10.700500000000002 31.423500000000008 47.664000000000001 25.456500000000002 54.013595092918763...
result:
ok 250 numbers
Test #3:
score: 0
Accepted
time: 1ms
memory: 4504kb
input:
3 1 -1 5 3.089 5.717 -2 0 2 4.806 3.257 0 -3 2 5.069 3.049 3 -2 -4 2 4.616 2.875 2 -2 4 5.798 3.097 -1 2 1 0.064 5.418 3 -1 1 2 4.105 3.883 0 5 4 1.936 4.292 2 -5 2 0.278 4.486 3 3 -5 5 3.208 4.696 -2 -4 3 3.609 0.906 -2 4 3 3.796 4.334 3 0 -1 1 4.313 0.711 2 -2 1 2.962 0.344 -4 2 5 2.524 3.043 3 -1...
output:
74.157879726552878 33.234999999999999 47.749461461744602 82.280000000000001 38.565000000000005 57.287499999999987 16.887500000000003 30.812466324073249 18.266137364384576 43.264634755237452 42.494217510621979 26.132749175803273 26.404500000000002 30.106728114671817 48.937000000000005 23.139500000000...
result:
ok 166 numbers
Test #4:
score: 0
Accepted
time: 2ms
memory: 4412kb
input:
4 4 3 4 1.727 2.114 -5 3 2 5.010 2.690 -1 1 5 4.078 2.852 1 5 5 2.974 4.884 4 3 4 1 5.626 2.021 2 -4 1 1.241 0.231 4 -4 5 0.323 5.472 -2 5 2 2.648 1.031 4 -1 -1 2 0.156 3.062 2 2 1 1.127 4.124 5 3 5 1.105 5.179 4 2 3 3.363 4.235 4 -2 -3 3 1.013 4.047 0 -5 5 1.829 4.952 -4 0 5 2.029 4.410 3 -1 4 1.40...
output:
89.059592091965939 71.472500000000011 72.359337599729827 126.255569920521992 53.321194904763871 59.877062378554669 47.616876770028647 66.382775434501397 26.793763102702933 32.341500000000003 139.853466960893428 81.663107773503000 102.706053155319424 81.919837964614146 30.252901352145077 88.100998126...
result:
ok 125 numbers
Test #5:
score: 0
Accepted
time: 2ms
memory: 4480kb
input:
5 -4 -1 4 2.566 3.253 1 -1 2 3.826 4.000 1 2 5 4.113 3.814 -1 -4 2 4.386 3.959 -1 -2 1 5.785 3.937 5 4 2 4 2.417 0.945 -5 -3 3 4.946 5.172 2 -2 2 2.380 0.205 3 3 4 0.766 4.402 -2 4 5 3.442 4.263 5 0 -4 3 5.172 0.603 -4 -5 3 1.321 3.688 -5 1 4 4.363 3.784 -5 -1 4 2.943 2.791 -2 5 3 5.292 5.765 5 -5 -...
output:
79.693585184955907 91.736875590339153 79.436470427630923 77.453260899735838 98.285986593755354 71.089224340747080 7.725500000000002 103.276610901060778 18.876111372247369 83.851724321134327 37.132095585543560 80.144201783696161 100.607500000000030 89.227847271325899 94.924728487345121 24.35600000000...
result:
ok 100 numbers
Test #6:
score: 0
Accepted
time: 3ms
memory: 4644kb
input:
10 4 4 4 2.043 4.661 0 -2 3 4.728 5.010 1 5 5 0.478 2.500 1 2 4 3.314 2.904 4 -4 5 3.408 5.869 -3 1 5 0.644 2.968 2 0 4 5.532 0.421 2 -3 1 3.492 0.855 -3 -3 5 4.475 4.896 -4 -1 3 0.873 1.815 10 -2 -1 3 4.786 3.714 -4 -3 1 0.155 4.804 -1 -5 3 4.225 2.500 -4 -1 4 5.536 3.954 4 -2 4 5.516 2.204 -3 2 4 ...
output:
217.462255720490276 137.080435157705892 68.280440686838574 81.674905544446716 161.394725071888985 109.854743305694640 88.851098028933578 149.663820955674510 141.260453837597538 150.828583153720501 103.530625418356806 80.042106264194871 135.587222368681921 124.154668157309558 142.296821200933607 136....
result:
ok 50 numbers
Test #7:
score: 0
Accepted
time: 0ms
memory: 4508kb
input:
9 6 -5 6 4.848 5.374 9 4 3 2.135 4.598 8 -4 6 4.443 5.157 0 5 9 3.605 1.226 7 -4 9 1.917 4.657 6 -7 8 3.621 0.258 3 3 4 1.955 5.563 -6 -5 5 3.174 3.778 -10 9 1 5.808 1.214 10 2 0 8 5.479 1.980 -3 -1 10 2.909 0.574 -8 -10 4 1.758 4.039 2 -6 9 5.761 4.499 1 1 2 0.115 0.897 -3 7 6 0.574 4.703 -4 5 6 0....
output:
340.572472199963727 423.411657030425545 188.493590961885133 663.645597577173476 237.474510029904366 435.602263268936952 426.132393829239049 393.573805742597528 204.877572258180095 211.300974323964084 159.246000000000066 84.711314252478473 65.409000000000006 288.210429276220964 53.787500000000009 323...
result:
ok 97 numbers
Test #8:
score: 0
Accepted
time: 3ms
memory: 4408kb
input:
10 -19 46 24 2.749 0.181 25 -35 45 5.805 4.054 -19 41 38 3.066 0.881 39 -15 22 5.876 4.537 -34 23 23 2.975 5.225 -21 -27 36 5.103 1.849 -43 -27 47 1.506 5.692 8 -12 16 2.217 3.584 -39 2 48 3.455 0.978 23 15 42 2.422 2.305 10 41 -31 32 2.089 3.004 -25 22 41 4.804 4.138 -25 32 37 0.576 3.483 -35 36 32...
output:
12052.406264363613445 8029.721602593825082 17841.160242547983216 8905.310278028087851 9364.474299758408961 11342.793063077788247 7432.277263249037787 4958.018309445384148 12178.815954973782937 12163.545508884981246 10152.091787750141521 5644.239555710109016 8047.133278497372885 10406.167543782268694...
result:
ok 50 numbers
Test #9:
score: 0
Accepted
time: 12ms
memory: 4680kb
input:
93 48 -38 55 2.613 0.385 28 53 75 4.293 2.033 88 33 4 3.991 5.533 11 57 6 4.203 2.347 95 71 11 4.082 3.258 -4 39 61 0.466 4.435 -28 -36 75 1.871 5.160 15 -42 18 2.512 3.285 -68 10 25 4.824 3.391 -61 -21 75 1.593 4.869 41 -30 36 0.436 3.602 -100 94 48 4.538 1.943 -1 19 73 1.400 1.056 -43 29 42 2.508 ...
output:
90187.884972229920095 95856.664895293375594 78262.905029265632038 76227.524853917566361 101278.184257132932544 89979.898975388772669 81706.668381387135014
result:
ok 7 numbers
Test #10:
score: 0
Accepted
time: 2ms
memory: 4504kb
input:
4 -46 6 35 0.448 0.600 -38 -36 29 2.044 0.247 87 -33 87 0.139 5.721 -22 -69 56 5.013 5.314 1 -16 11 41 4.997 5.257 10 -80 -53 86 4.687 1.234 -76 -66 64 4.487 2.231 -46 3 39 5.532 4.214 -16 -94 70 1.841 2.220 -66 98 2 4.388 5.140 1 53 15 2.496 0.741 79 79 79 2.831 2.307 -16 10 92 4.938 3.805 -98 65 7...
output:
28820.394977238749561 4418.508499999999913 33061.953463050653227 45686.056434966187226 12072.339439476245389 5985.184023385510955 50770.001552460576931 42946.205898987405817 20200.603769154655311 36999.657973594548821 4337.215999999999440 5574.280499999998028 35395.913270822020422 24095.705148067114...
result:
ok 89 numbers
Test #11:
score: 0
Accepted
time: 3ms
memory: 4548kb
input:
33 -20 33 3 4.628 3.531 -43 10 4 5.952 4.299 49 -32 7 4.523 5.619 31 -15 5 4.429 1.704 50 40 14 4.025 0.773 -44 -14 31 0.113 2.654 -48 -16 2 4.571 2.209 16 14 11 3.296 3.719 34 -7 17 5.346 2.974 6 -45 22 3.532 2.678 -45 -14 33 3.100 1.706 -30 42 43 2.729 3.312 44 16 46 1.660 2.278 40 44 1 3.442 3.05...
output:
15802.283167443218190 21353.722702477982239 17122.857671863144787 17218.507770068510581 20193.954959457001678 18206.933769756462425 16965.217283117555780 19853.432944954329287 18881.619820128016727 12897.384431902635697 17739.729509985430923 20560.400965029879444 21622.473383571323211 21926.10674976...
result:
ok 14 numbers
Test #12:
score: 0
Accepted
time: 19ms
memory: 4788kb
input:
100 7 -66 7 3.504 5.074 -99 4 5 2.346 0.874 -68 93 47 4.684 5.490 89 46 87 4.250 0.385 46 79 87 2.659 5.715 -10 34 60 3.444 1.728 -82 69 83 4.298 2.078 -75 28 57 1.351 3.565 3 69 97 2.213 3.702 31 8 14 2.294 0.927 97 -23 65 1.493 1.414 55 47 45 2.466 4.113 -78 58 91 1.963 5.592 -97 49 84 4.659 1.604...
output:
96546.677629778860137 101085.301215711428085 104860.539882848359412 82685.042951206516591 87897.311215470079333
result:
ok 5 numbers
Test #13:
score: 0
Accepted
time: 49ms
memory: 6888kb
input:
500 1 -1 2 1.046 1.346 2 2 1 5.506 0.926 0 -2 2 5.468 3.385 0 -1 1 2.747 4.753 1 -2 2 1.805 5.313 2 0 2 1.543 3.123 2 2 2 1.604 0.801 0 -1 2 4.470 5.702 -1 2 2 1.725 4.320 1 1 1 3.526 5.798 2 0 2 2.157 3.678 -2 -2 2 3.575 0.905 -1 0 2 0.226 3.358 -1 0 2 0.655 0.196 -2 -2 1 4.774 0.375 -1 1 2 2.597 1...
output:
60.229840328281888
result:
ok found '60.2298403', expected '60.2298403', error '0.0000000'
Test #14:
score: 0
Accepted
time: 59ms
memory: 7276kb
input:
500 -3 -3 1 4.530 5.443 0 0 2 5.225 2.961 -2 3 3 0.553 3.603 2 3 1 3.997 3.909 3 -1 2 4.323 5.990 -3 -2 2 1.844 3.239 1 3 2 4.381 4.342 3 -3 2 5.542 4.859 1 1 3 5.812 2.058 1 0 3 4.137 5.145 -3 1 1 1.968 5.381 -3 0 1 5.792 5.585 3 -3 2 2.248 5.630 -2 -3 2 4.869 3.928 1 2 2 3.471 1.300 1 3 3 3.349 1....
output:
127.130359286166097
result:
ok found '127.1303593', expected '127.1303593', error '0.0000000'
Test #15:
score: 0
Accepted
time: 71ms
memory: 7708kb
input:
500 -2 -3 3 2.226 2.479 1 2 2 4.733 2.677 1 -1 4 1.639 0.785 0 -1 4 1.658 5.930 1 -1 2 0.839 0.766 1 4 2 5.733 3.355 1 -3 3 4.533 4.848 -3 0 4 2.815 5.893 1 -1 3 1.486 3.819 -1 4 2 3.573 2.616 -3 -1 2 1.991 2.342 -2 1 1 4.208 0.340 -4 -1 2 0.683 3.160 -1 2 4 4.469 2.477 3 -1 4 2.169 1.067 2 4 2 4.10...
output:
226.537907106410245
result:
ok found '226.5379071', expected '226.5379071', error '0.0000000'
Test #16:
score: 0
Accepted
time: 82ms
memory: 8764kb
input:
500 1 -4 3 0.955 4.537 -6 -8 5 2.270 2.636 0 -8 6 2.832 0.248 5 -10 5 3.043 4.276 -8 7 5 0.498 5.868 4 2 1 0.859 5.246 5 2 6 3.800 0.490 -4 9 1 5.411 3.038 -7 -5 8 3.363 4.987 10 8 3 1.132 5.824 -5 1 1 4.473 5.142 3 8 3 1.239 0.169 9 8 10 1.572 3.165 -9 -6 1 5.417 0.808 -1 9 7 3.432 2.583 -5 -5 10 2...
output:
1290.241987371735377
result:
ok found '1290.2419874', expected '1290.2419874', error '0.0000000'
Test #17:
score: 0
Accepted
time: 93ms
memory: 8608kb
input:
500 46 -1 28 2.976 5.503 -33 13 22 1.994 2.281 -8 -21 45 0.225 2.374 20 -16 50 1.846 4.885 -47 18 16 3.164 4.896 -50 -50 29 4.952 3.139 -30 -25 36 3.288 5.414 7 22 38 1.624 2.048 38 -42 36 4.738 4.037 45 -21 26 0.862 3.469 49 31 24 2.272 2.713 -20 33 49 5.034 2.956 22 -35 43 3.503 3.866 -44 -40 1 4....
output:
30725.286701907891256
result:
ok found '30725.2867019', expected '30725.2867019', error '0.0000000'
Test #18:
score: 0
Accepted
time: 93ms
memory: 8596kb
input:
500 -30 -70 60 0.367 1.785 67 -49 33 4.479 4.251 49 69 23 3.739 3.621 -4 -79 78 5.223 4.472 76 -9 55 2.756 2.683 -92 68 46 4.485 1.664 -70 -99 83 2.169 2.224 -51 -44 37 5.120 2.789 77 1 14 1.546 0.104 31 1 5 4.427 3.778 95 -69 8 2.224 3.618 43 13 56 3.825 4.428 -22 -14 86 4.380 5.071 -32 -66 70 0.18...
output:
116138.459039379842579
result:
ok found '116138.4590394', expected '116138.4590394', error '0.0000000'
Test #19:
score: 0
Accepted
time: 0ms
memory: 4500kb
input:
1 -67 -57 95 5.527 5.362 5 -81 35 2 4.896 0.559 46 -93 2 2.108 2.103 -53 -83 90 3.952 4.883 -46 0 85 1.526 0.489 -59 49 72 4.560 2.778 2 23 67 64 5.290 2.804 89 27 23 0.733 5.058 5 20 62 53 4.727 5.415 24 52 62 4.999 4.205 -37 34 52 1.350 3.179 -43 76 83 0.130 5.985 -22 58 40 5.372 2.233 4 32 -96 83...
output:
24196.025000000001455 26709.166491608753859 6850.879799513089893 26614.846152865549811 11694.216934510921419 11487.743999999998778 327.184000000000310 9187.735767648826368 15880.670943644554427 27506.634468116440985 1788.125000000000000 10038.206999999998516 5846.010824241443515 22964.37432025548696...
result:
ok 167 numbers
Test #20:
score: 0
Accepted
time: 2ms
memory: 4456kb
input:
7 -47 -83 100 0.358 0.553 -71 97 98 1.499 3.915 17 -56 7 5.884 4.913 -18 20 52 3.900 3.718 8 29 60 0.002 2.098 -57 78 92 1.389 4.503 -60 45 98 5.668 4.783 7 -40 72 34 2.067 2.870 59 2 44 0.909 3.929 -83 15 62 3.224 3.054 -20 92 41 3.624 1.958 -64 44 67 1.002 3.405 70 -36 2 1.231 2.321 96 -87 10 1.92...
output:
38003.545741749680019 18615.980387945015536 30226.618185405655822 39138.651119082103833 39292.940077121878858 18460.238747751322080 23656.361897610342567 12845.720142760603267 37815.526148763521633 40040.124981319138897 43511.681965935407788 47180.773313263991440 27510.089072426359053 45552.13740957...
result:
ok 68 numbers
Test #21:
score: 0
Accepted
time: 86ms
memory: 8076kb
input:
500 4 1 1 5.923 2.552 3 5 2 0.653 3.552 1 2 3 2.725 5.745 1 -5 5 5.109 5.085 5 4 4 5.769 0.284 -3 -5 4 5.822 5.349 5 1 5 4.898 2.489 4 -3 4 3.888 5.049 3 0 4 5.361 0.398 -3 2 1 0.595 1.964 1 3 2 1.803 4.045 -2 -4 3 0.423 3.862 -2 1 2 2.705 0.690 -2 -3 3 2.682 2.185 -5 -5 2 3.279 0.115 3 -1 1 1.054 4...
output:
345.294170916385895
result:
ok found '345.2941709', expected '345.2941709', error '0.0000000'
Test #22:
score: 0
Accepted
time: 4ms
memory: 4512kb
input:
20 1 -35 10 3.746 3.231 24 52 90 3.896 3.562 -31 -61 75 3.823 2.329 29 -47 12 5.283 3.069 32 46 27 4.296 2.086 97 84 2 0.303 0.569 -1 97 5 4.166 5.644 71 -10 27 4.551 1.998 -16 -67 68 0.284 4.399 -90 -85 73 2.860 0.721 1 62 25 0.477 2.143 -46 -39 68 4.174 5.375 67 28 21 4.230 4.981 -22 -94 21 4.695 ...
output:
44998.723669597005937 26372.770547088453895 72184.119494019832928 47425.853590896993410 51623.399454197344312 33080.337986300124612 32731.071691809560434 45734.218398016433639 43352.520559914250043 57111.145591989239620 67496.696175494333147 28824.690509992236912 52331.899389117243118 42836.03087637...
result:
ok 32 numbers
Extra Test:
score: 0
Extra Test Passed