QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#323669#5104. Guardians of the Gallerycrimson231AC ✓65ms4416kbC++147.8kb2024-02-10 09:59:082024-02-10 09:59:09

Judging History

你现在查看的是最新测评结果

  • [2024-02-10 09:59:09]
  • 评测
  • 测评结果:AC
  • 用时:65ms
  • 内存:4416kb
  • [2024-02-10 09:59:08]
  • 提交

answer

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
typedef long long ll;
//typedef long double ld;
typedef double ld;
const ld TOL = 1e-8;
const ld INF = 1e17;
const int LEN = 102;
int N, t;
ld COST[LEN];

struct Info {
	int i;
	ld c;
	bool operator < (const Info& x) const { return c > x.c; }
};
std::vector<Info> G[LEN];
std::priority_queue<Info> Q;
ld dijkstra(int v, int g) {
	for (int i = 0; i < LEN; i++) COST[i] = INF;
	Q.push({ v, 0 });
	COST[v] = 0;
	while (Q.size()) {
		Info p = Q.top(); Q.pop();
		if (p.c > COST[p.i]) continue;
		for (const Info& w : G[p.i]) {
			ld cost = p.c + w.c;
			if (COST[w.i] > cost) {
				COST[w.i] = cost;
				Q.push({ w.i, cost });
			}
		}
	}
	return COST[g];
}
bool z(const ld& x) { return std::abs(x) < TOL; }
struct Pos {
	ld x, y;
	int i;
	Pos(ld X, ld Y, int I) : x(X), y(Y), i(I) {}
	Pos() : x(0), y(0), i(0) {}
	bool operator == (const Pos& p) const { return z(x - p.x) && z(y - p.y); }
	bool operator < (const Pos& p) const { return z(x - p.x) ? y < p.y : x < p.x; }
	Pos operator + (const Pos& p) const { return { x + p.x, y + p.y, 0 }; }
	Pos operator - (const Pos& p) const { return { x - p.x, y - p.y, 0 }; }
	Pos operator * (const ld& n) const { return { x * n, y * n, 0 }; }
	Pos operator / (const ld& n) const { return { x / n, y / n, 0 }; }
	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 operator ~ () const { return { -y, x, 0 }; }
	ld operator ! () const { return x * y; }
	Pos& operator += (const Pos& p) { x += p.x; y += p.y; return *this; }
	Pos& operator *= (const ld& scale) { x *= scale; y *= scale; return *this; }
	ld mag() const { return hypot(x, y); }
} gallery[LEN], nodes[LEN], sculpture{ 0, 0, 0 }, guard{ 0, 0, 1 };// const Pos O = { 0, 0, -1 };
struct Vec {
	ld vy, vx;
	bool operator < (const Vec& v) const { return z(vy - v.vy) ? vx < v.vx : vy < v.vy; }
	bool operator == (const Vec& v) const { return (z(vy - v.vy) && z(vx - v.vx)); }
	ld operator / (const Vec& v) const { return vy * v.vx - vx * v.vy; }
	Vec operator ~ () const { return { -vx, vy }; }
}; const Vec Zero = { 0, 0 };
struct Line {
	Vec s;
	ld c;
	bool operator < (const Line& l) const {
		bool f1 = Zero < s;
		bool f2 = Zero < l.s;
		if (f1 != f2) return f1;
		ld ccw = s / l.s;
		return z(ccw) ? c * hypot(l.s.vy, l.s.vx) < l.c * hypot(s.vy, s.vx) : ccw > 0;
	}
	ld operator / (const Line& l) const { return s / l.s; }
};
Line L(const Pos& s, const Pos& e) {
	ld dy, dx, c;
	dy = e.y - s.y;
	dx = s.x - e.x;
	c = dy * s.x + dx * s.y;
	return { { dy, dx } , c };
}
Line rotate90(const Line& l, const Pos& p) {
	Vec s = ~l.s;
	ld c = s.vy * p.x + s.vx * p.y;
	return { s, c };
}
Pos intersection(const Line& l1, const Line& l2) {
	Vec v1 = l1.s, v2 = l2.s;
	ld det = v1 / v2;
	return {
		(l1.c * v2.vx - l2.c * v1.vx) / det,
		(l2.c * v1.vy - l1.c * v2.vy) / det,
		0
	};
}
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) {
	ld ret = cross(d1, d2, d3);
	return z(ret) ? 0 : ret > 0 ? 1 : -1;
}
ld dot(const Pos& d1, const Pos& d2, const Pos& d3) { return (d2 - d1) * (d3 - d2); }
bool on_seg_strong(const Pos& d1, const Pos& d2, const Pos& d3) {
	ld ret = dot(d1, d3, d2);
	return z(cross(d1, d2, d3)) && (ret > 0 || z(ret));
}
bool on_seg_weak(const Pos& d1, const Pos& d2, const Pos& d3) {
	ld ret = dot(d1, d3, d2);
	return z(cross(d1, d2, d3)) && ret > 0;
}
bool inner_check(Pos H[], const int& sz, const Pos& p) {
	int cnt{ 0 };
	for (int i = 0; i < sz; i++) {
		Pos cur = H[i], nxt = H[(i + 1) % sz];
		if (on_seg_strong(cur, nxt, p)) return 1;
		if (z(cur.y - nxt.y)) continue;
		if (nxt.y < cur.y) std::swap(cur, nxt);
		if (nxt.y - TOL < p.y || cur.y > p.y) continue;
		cnt += ccw(cur, nxt, p) > 0;
	}
	return cnt & 1;
}
bool intersect(const Pos& s1, const Pos& s2, const Pos& d1, const Pos& d2) {
	bool f1 = ccw(s1, s2, d1) * ccw(s2, s1, d2) > 0;
	bool f2 = ccw(d1, d2, s1) * ccw(d2, d1, s2) > 0;
	return f1 && f2;
}
bool blocked(const Pos& s1, const Pos& s2, const Pos& d1, const Pos& d2) {
	bool f1 = ccw(s1, s2, d1) * ccw(s2, s1, d2) > 0;
	bool f2 = ccw(d1, d2, s1) * ccw(d2, d1, s2) > 0;
	bool f3 = on_seg_weak(s1, s2, d1) || on_seg_weak(s1, s2, d2);
	return (f1 && f2) || f3;
}
bool blocked(Pos H[], const int& sz, const Pos& s1, const Pos& s2) {
	for (int i = 0; i < sz; i++) if (blocked(s1, s2, H[i], H[(i + 1) % sz])) return 1;
	return 0;
}
bool invisible(Pos H[], const int& sz, const Pos& p, const Pos& target) {
	bool l{ 0 }, r{ 0 };
	for (int i = 0; i < sz; i++) {
		Pos cur = H[i], nxt = H[(i + 1) % sz];
		if (!ccw(p, target, cur) && !ccw(p, target, nxt)) continue;
		if (intersect(p, target, cur, nxt)) return 1;
		if (on_seg_weak(p, target, cur) && ccw(p, target, nxt) > 0) l = 1;
		if (on_seg_weak(p, target, nxt) && ccw(p, target, cur) > 0) l = 1;
		if (on_seg_weak(p, target, cur) && ccw(p, target, nxt) < 0) r = 1;
		if (on_seg_weak(p, target, nxt) && ccw(p, target, cur) < 0) r = 1;
		if (l && r) return 1;
	}
	return 0;
}
bool visible(Pos H[], const int& sz, const Pos& p,  const Pos& inx, const Pos& target) {
	return !blocked(H, sz, p, inx)
		&& !invisible(H, sz, inx, target)
		&& inner_check(H, sz, inx)
		&& inner_check(H, sz, (p + inx) * .5);
}
void init() {//O(N^4)
	std::cin.tie(0)->sync_with_stdio(0);
	std::cout.tie(0);
	std::cout << std::fixed;
	std::cout.precision(7);
	std::cin >> N;
	for (int i = 0; i < N; i++) std::cin >> gallery[i].x >> gallery[i].y, gallery[i].i = i + 2;
	std::cin >> guard.x >> guard.y >> sculpture.x >> sculpture.y;
	sculpture.i = 0;
	guard.i = 1;

	if (!invisible(gallery, N, guard, sculpture)) { G[1].push_back({ 0, 0 }); return; }

	t = 0;
	nodes[t++] = sculpture;
	nodes[t++] = guard;
	Pos seg;
	for (int i = 0; i < N; i++) nodes[t++] = gallery[i];
	for (int i = 1; i < t; i++) {
		if (!invisible(gallery, N, nodes[i], nodes[0])) G[i].push_back({ 0, 0 });
		for (int j = i + 1; j < t; j++) {
			if (!blocked(gallery, N, nodes[i], nodes[j])
				&& inner_check(gallery, N, (nodes[i] + nodes[j]) * .5)) {
				seg = nodes[i] - nodes[j];
				G[i].push_back({ j, seg.mag() });
				G[j].push_back({ i, seg.mag() });
			}
		}
	}
	Line view_line, last;
	Pos inx;
	for (int i = 0; i < N; i++) {
		view_line = L(sculpture, gallery[i]);
		last = rotate90(view_line, guard);
		inx = intersection(view_line, last);
		if (visible(gallery, N, guard, inx, sculpture))
			G[guard.i].push_back({ 0, (guard - inx).mag() });
		for (int j = 0; j < N; j++) {
			if (i == j) continue;
			Pos cur = gallery[j], pre = gallery[(j + N - 1) % N], nxt = gallery[(j + 1) % N];
			last = rotate90(view_line, cur);
			inx = intersection(view_line, last);
			if (visible(gallery, N, cur, inx, sculpture))
				G[gallery[j].i].push_back({ 0, (cur - inx).mag() });
			last = L(cur, pre);
			inx = intersection(view_line, last);
			if (on_seg_weak(cur, pre, inx) && !invisible(gallery, N, inx, sculpture)) {
				G[gallery[j].i].push_back({ 0, (cur - inx).mag() });
				for (int k = 1; k < t; k++) 
					if (!blocked(gallery, N, nodes[k], inx) && inner_check(gallery, N, (nodes[k] + inx) * .5))
						G[nodes[k].i].push_back({ 0, (nodes[k] - inx).mag() });
			}
			last = L(cur, nxt);
			inx = intersection(view_line, last);
			if (on_seg_weak(cur, nxt, inx) && !invisible(gallery, N, inx, sculpture)) {
				G[gallery[j].i].push_back({ 0, (cur - inx).mag() });
				for (int k = 1; k < t; k++)
					if (!blocked(gallery, N, nodes[k], inx) && inner_check(gallery, N, (nodes[k] + inx) * .5))
						G[nodes[k].i].push_back({ 0, (nodes[k] - inx).mag() });
			}
		}
	}
	return;
}
void solve() { init(); std::cout << dijkstra(1, 0) << "\n"; return; }
int main() { solve(); return 0; }//boj26133

详细

Test #1:

score: 100
Accepted
time: 1ms
memory: 3968kb

input:

15
13 7
20 20
39 20
49 7
73 13
100 5
117 38
98 20
80 20
66 40
68 20
51 20
41 39
22 48
2 39
10 20
104 20

output:

29.0000000

result:

ok found '29.0000000', expected '29.0000000', error '0.0000000'

Test #2:

score: 0
Accepted
time: 1ms
memory: 4020kb

input:

16
39 2
48 22
39 41
20 51
20 68
40 66
20 80
20 98
38 117
5 100
13 73
7 49
19 39
20 23
20 20
7 13
20 10
20 104

output:

13.0000000

result:

ok found '13.0000000', expected '13.0000000', error '0.0000000'

Test #3:

score: 0
Accepted
time: 1ms
memory: 4076kb

input:

16
13 33
20 60
23 66
39 97
49 105
73 166
100 205
117 272
98 216
80 180
66 172
68 156
51 122
41 121
22 92
2 44
10 40
104 228

output:

140.8722826

result:

ok found '140.8722826', expected '140.8722826', error '0.0000000'

Test #4:

score: 0
Accepted
time: 1ms
memory: 3956kb

input:

16
64 17
50 28
67 23
65 18
77 4
88 20
78 10
70 29
61 28
47 32
54 17
43 13
35 20
41 30
27 20
42 6
81 12
33 23

output:

64.2045377

result:

ok found '64.2045377', expected '64.2045377', error '0.0000000'

Test #5:

score: 0
Accepted
time: 1ms
memory: 4040kb

input:

16
64 17
50 28
67 23
65 18
77 4
88 20
78 10
70 29
61 28
47 32
54 17
43 13
35 20
41 30
27 20
42 6
33 23
81 12

output:

72.2834980

result:

ok found '72.2834980', expected '72.2834980', error '0.0000000'

Test #6:

score: 0
Accepted
time: 0ms
memory: 4008kb

input:

7
76 8
389 215
691 19
407 331
489 397
300 403
363 334
126 60
393 370

output:

6.6579178

result:

ok found '6.6579178', expected '6.6579178', error '0.0000000'

Test #7:

score: 0
Accepted
time: 0ms
memory: 3960kb

input:

3
0 1000
1000 0
1000 1000
567 578
589 601

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #8:

score: 0
Accepted
time: 0ms
memory: 3960kb

input:

3
0 1000
0 0
1000 0
366 366
367 366

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #9:

score: 0
Accepted
time: 0ms
memory: 3976kb

input:

5
50 93
278 178
199 300
596 362
208 519
421 388
142 153

output:

175.1697594

result:

ok found '175.1697594', expected '175.1697594', error '0.0000000'

Test #10:

score: 0
Accepted
time: 0ms
memory: 3976kb

input:

7
50 93
278 178
199 300
401 312
483 162
596 362
208 519
488 252
142 153

output:

289.6821399

result:

ok found '289.6821399', expected '289.6821399', error '0.0000000'

Test #11:

score: 0
Accepted
time: 0ms
memory: 3956kb

input:

8
10 10
40 25
20 25
20 35
12 23
30 23
10 20
5 40
15 15
19 26

output:

25.0000000

result:

ok found '25.0000000', expected '25.0000000', error '0.0000000'

Test #12:

score: 0
Accepted
time: 0ms
memory: 3976kb

input:

9
5 1000
6 3
5 999
0 1000
0 0
500 2
500 0
1000 0
1000 1000
1 4
993 1

output:

5.1010479

result:

ok found '5.1010479', expected '5.1010479', error '0.0000000'

Test #13:

score: 0
Accepted
time: 25ms
memory: 4180kb

input:

100
695 43
538 87
463 208
597 329
750 306
812 481
960 555
912 344
983 450
987 573
994 852
941 985
801 855
792 800
849 806
792 696
924 701
939 672
710 546
722 668
723 807
715 767
624 524
634 554
547 503
357 352
627 458
651 495
937 558
932 545
864 509
753 489
509 397
341 335
300 495
199 528
380 688
48...

output:

1695.1865730

result:

ok found '1695.1865730', expected '1695.1865730', error '0.0000000'

Test #14:

score: 0
Accepted
time: 1ms
memory: 4028kb

input:

20
840 854
839 45
996 905
959 938
852 938
730 423
425 493
136 481
213 778
527 740
691 941
22 830
83 313
462 155
636 21
462 321
360 324
238 422
402 492
806 406
952 822
410 838

output:

1424.3842015

result:

ok found '1424.3842015', expected '1424.3842015', error '0.0000000'

Test #15:

score: 0
Accepted
time: 16ms
memory: 4116kb

input:

74
89 395
52 622
124 832
115 698
95 598
199 491
190 356
191 398
132 315
94 371
34 221
91 0
153 139
220 465
260 283
312 30
409 15
338 50
343 52
437 69
359 89
332 213
377 505
375 396
405 199
657 90
658 50
360 50
618 23
642 7
824 191
688 417
795 227
709 286
662 321
646 175
485 210
381 357
420 329
441 3...

output:

2036.7557099

result:

ok found '2036.7557099', expected '2036.7557099', error '0.0000000'

Test #16:

score: 0
Accepted
time: 34ms
memory: 4200kb

input:

100
380 626
511 639
548 551
651 476
706 462
636 604
652 617
776 577
794 566
821 433
765 410
778 276
735 345
700 329
448 550
283 482
537 332
706 213
741 204
833 152
657 182
626 173
568 225
602 213
673 203
537 286
459 317
609 261
493 344
334 430
468 338
331 400
350 326
512 197
553 155
424 120
446 179
...

output:

307.8507109

result:

ok found '307.8507109', expected '307.8507109', error '0.0000000'

Test #17:

score: 0
Accepted
time: 41ms
memory: 4104kb

input:

100
425 641
614 667
719 714
598 761
548 727
505 713
415 832
505 856
724 762
764 767
803 755
773 727
826 633
832 509
842 570
829 456
742 430
706 513
604 527
942 208
912 569
959 330
975 605
977 878
882 609
844 694
869 789
930 896
992 894
763 937
699 930
701 854
732 810
709 820
657 881
507 896
342 805
...

output:

1941.5687357

result:

ok found '1941.5687357', expected '1941.5687357', error '0.0000000'

Test #18:

score: 0
Accepted
time: 43ms
memory: 4216kb

input:

100
845 528
842 889
837 997
809 663
786 746
793 554
782 470
769 798
709 992
520 993
95 983
191 897
250 666
136 715
139 745
32 979
32 918
5 916
0 740
31 283
10 238
36 177
102 740
141 635
145 353
132 435
106 607
130 383
41 66
139 12
403 11
330 45
225 48
153 216
251 342
233 374
289 424
266 99
334 62
34...

output:

1863.5717403

result:

ok found '1863.5717403', expected '1863.5717403', error '0.0000000'

Test #19:

score: 0
Accepted
time: 0ms
memory: 3820kb

input:

4
0 0
1000 0
1000 1000
0 1000
4 939
27 58

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #20:

score: 0
Accepted
time: 33ms
memory: 4152kb

input:

94
5 5
995 5
995 995
5 995
990 990
5 990
970 970
5 970
950 950
5 950
930 930
5 930
910 910
5 910
890 890
5 890
870 870
5 870
850 850
5 850
830 830
5 830
810 810
5 810
790 790
5 790
770 770
5 770
750 750
5 750
730 730
5 730
710 710
5 710
690 690
5 690
670 670
5 670
650 650
5 650
630 630
5 630
610 610...

output:

620.2910607

result:

ok found '620.2910607', expected '620.2910607', error '0.0000000'

Test #21:

score: 0
Accepted
time: 0ms
memory: 3992kb

input:

8
0 0
20 0
20 30
60 30
60 0
80 0
80 50
0 50
70 30
70 10

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #22:

score: 0
Accepted
time: 0ms
memory: 3972kb

input:

5
2 0
10 0
0 10
0 3
5 3
1 8
5 2

output:

5.0000000

result:

ok found '5.0000000', expected '5.0000000', error '0.0000000'

Test #23:

score: 0
Accepted
time: 0ms
memory: 3964kb

input:

5
2 0
10 0
0 10
0 3
5 3
1 4
5 2

output:

4.0000000

result:

ok found '4.0000000', expected '4.0000000', error '0.0000000'

Test #24:

score: 0
Accepted
time: 1ms
memory: 4016kb

input:

12
0 0
2 0
2 4
1 4
1 5
2 5
2 7
0 7
0 3
1 3
1 2
0 2
1 6
1 1

output:

2.0000000

result:

ok found '2.0000000', expected '2.0000000', error '0.0000000'

Test #25:

score: 0
Accepted
time: 1ms
memory: 4064kb

input:

10
0 0
2 0
2 4
1 4
2 5
2 7
0 7
0 3
1 2
0 2
1 6
1 1

output:

2.0000000

result:

ok found '2.0000000', expected '2.0000000', error '0.0000000'

Test #26:

score: 0
Accepted
time: 0ms
memory: 4012kb

input:

12
0 0
2 0
3 3
5 0
6 3
7 0
8 2
7 6
5 2
4 6
2 2
0 2
1 1
7 1

output:

6.4787087

result:

ok found '6.4787087', expected '6.4787087', error '0.0000000'

Test #27:

score: 0
Accepted
time: 0ms
memory: 4024kb

input:

8
10 0
11 3
12 0
14 0
15 3
16 0
18 4
8 4
10 1
16 1

output:

5.8761229

result:

ok found '5.8761229', expected '5.8761229', error '0.0000000'

Test #28:

score: 0
Accepted
time: 0ms
memory: 4012kb

input:

8
10 0
11 3
12 0
16 3
14 0
17 0
17 4
8 4
10 1
15 1

output:

7.2360680

result:

ok found '7.2360680', expected '7.2360680', error '0.0000000'

Test #29:

score: 0
Accepted
time: 1ms
memory: 3976kb

input:

8
0 0
20 0
20 30
60 30
60 0
80 0
80 50
0 50
70 10
10 10

output:

58.1377674

result:

ok found '58.1377674', expected '58.1377674', error '0.0000000'

Test #30:

score: 0
Accepted
time: 1ms
memory: 3972kb

input:

11
0 0
4 0
4 1
5 1
5 0
7 0
7 2
3 2
3 1
2 2
0 2
6 1
1 1

output:

2.0000000

result:

ok found '2.0000000', expected '2.0000000', error '0.0000000'

Test #31:

score: 0
Accepted
time: 0ms
memory: 3940kb

input:

3
31 41
59 26
53 58
36 41
56 31

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #32:

score: 0
Accepted
time: 16ms
memory: 3996kb

input:

97
6 10
8 10
8 12
6 12
6 14
4 8
2 6
2 10
4 10
2 12
4 12
4 14
0 14
0 0
4 0
4 2
2 2
2 4
4 4
4 6
6 6
6 8
8 4
8 2
6 4
6 0
8 0
10 2
10 0
16 0
12 2
16 2
18 0
22 0
12 4
22 4
22 6
24 6
24 2
18 2
24 0
26 2
26 6
22 8
14 10
32 10
24 8
26 8
28 6
28 2
26 0
30 0
32 2
36 4
36 2
34 2
32 0
38 0
38 6
30 2
32 4
30 4
3...

output:

72.4810351

result:

ok found '72.4810351', expected '72.4810351', error '0.0000000'

Test #33:

score: 0
Accepted
time: 34ms
memory: 4044kb

input:

97
180 20
190 20
170 30
160 30
160 40
170 40
180 30
190 30
190 40
180 40
170 50
160 50
160 60
170 60
180 50
190 50
180 60
190 60
190 70
150 60
100 50
110 50
110 30
100 30
100 40
90 40
90 30
80 40
80 30
70 20
70 30
50 30
60 40
70 40
50 60
80 60
70 50
90 50
90 60
140 60
180 70
60 70
30 60
50 70
20 70
...

output:

240.4783857

result:

ok found '240.4783857', expected '240.4783857', error '0.0000000'

Test #34:

score: 0
Accepted
time: 27ms
memory: 4192kb

input:

89
10 15
10 10
5 10
5 15
0 15
0 0
5 0
5 5
15 5
10 0
100 0
20 5
25 5
15 10
85 10
30 5
90 5
105 0
285 0
295 5
350 5
290 0
445 0
355 5
380 5
450 0
735 0
715 5
665 5
710 10
730 10
720 5
735 5
740 0
745 0
740 5
745 5
745 15
740 10
735 10
740 15
685 15
705 10
630 10
660 5
590 5
610 10
625 10
680 15
615 15...

output:

306.4578983

result:

ok found '306.4578983', expected '306.4578983', error '0.0000000'

Test #35:

score: 0
Accepted
time: 15ms
memory: 3952kb

input:

94
5 5
995 5
995 995
5 995
990 990
5 990
970 970
5 970
950 950
5 950
930 930
5 930
910 910
5 910
890 890
5 890
870 870
5 870
850 850
5 850
830 830
5 830
810 810
5 810
790 790
5 790
770 770
5 770
750 750
5 750
730 730
5 730
710 710
5 710
690 690
5 690
670 670
5 670
650 650
5 650
630 630
5 630
610 610...

output:

1306.7333316

result:

ok found '1306.7333316', expected '1306.7333316', error '0.0000000'

Test #36:

score: 0
Accepted
time: 27ms
memory: 4036kb

input:

100
1000 20
1 40
1000 60
1 80
1000 100
1 120
1000 140
1 160
1000 180
1 200
1000 220
1 240
1000 260
1 280
1000 300
1 320
1000 340
1 360
1000 380
1 400
1000 420
1 440
1000 460
1 480
1000 500
1 520
1000 540
1 560
1000 580
1 600
1000 620
1 640
1000 660
1 680
1000 700
1 720
1000 740
1 760
1000 780
1 800
...

output:

47913.5987375

result:

ok found '47913.5987375', expected '47913.5987375', error '0.0000000'

Test #37:

score: 0
Accepted
time: 24ms
memory: 4008kb

input:

100
0 0
1000 0
1000 1000
0 1000
0 3
998 2
998 998
2 998
2 5
996 4
996 996
4 996
4 7
994 6
994 994
6 994
6 9
992 8
992 992
8 992
8 11
990 10
990 990
10 990
10 13
988 12
988 988
12 988
12 15
986 14
986 986
14 986
14 17
984 16
984 984
16 984
16 19
982 18
982 982
18 982
18 21
980 20
980 980
20 980
20 23...

output:

46834.0056362

result:

ok found '46834.0056362', expected '46834.0056362', error '0.0000000'

Test #38:

score: 0
Accepted
time: 1ms
memory: 3992kb

input:

100
7 409
21 321
39 254
62 198
74 177
79 169
96 146
105 135
118 120
154 90
181 72
188 68
199 62
210 57
219 53
239 45
311 24
320 22
356 15
376 12
408 8
483 2
499 1
500 1
516 2
570 6
581 7
630 13
746 40
749 41
768 48
780 53
823 75
834 82
845 90
854 97
903 146
913 159
925 177
964 267
972 295
973 299
98...

output:

0.0000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #39:

score: 0
Accepted
time: 0ms
memory: 4064kb

input:

13
100 100
110 110
100 120
110 130
100 140
110 150
100 160
90 155
100 145
90 135
100 125
90 115
100 105
100 106
100 159

output:

34.0000000

result:

ok found '34.0000000', expected '34.0000000', error '0.0000000'

Test #40:

score: 0
Accepted
time: 0ms
memory: 4032kb

input:

13
100 100
110 90
120 100
130 90
140 100
150 90
160 100
155 110
145 100
135 110
125 100
115 110
105 100
106 100
159 100

output:

34.0000000

result:

ok found '34.0000000', expected '34.0000000', error '0.0000000'

Test #41:

score: 0
Accepted
time: 1ms
memory: 4072kb

input:

13
100 100
120 100
120 120
140 120
140 140
160 140
160 160
145 165
145 145
125 145
125 125
105 125
105 105
106 106
159 159

output:

48.0832611

result:

ok found '48.0832611', expected '48.0832611', error '0.0000000'

Test #42:

score: 0
Accepted
time: 1ms
memory: 4020kb

input:

13
100 100
100 120
80 120
80 140
60 140
60 160
40 160
35 145
55 145
55 125
75 125
75 105
95 105
94 106
41 159

output:

48.0832611

result:

ok found '48.0832611', expected '48.0832611', error '0.0000000'

Test #43:

score: 0
Accepted
time: 65ms
memory: 4416kb

input:

100
7 409
21 321
39 254
62 198
74 177
79 169
96 146
105 135
118 120
154 90
181 72
188 68
199 62
210 57
219 53
239 45
311 24
320 22
356 15
376 12
408 8
483 2
499 1
500 1
516 2
570 6
581 7
630 13
746 40
749 41
768 48
780 53
823 75
834 82
845 90
854 97
903 146
913 159
925 177
964 267
972 295
981 335
99...

output:

467.0010707

result:

ok found '467.0010707', expected '467.0010707', error '0.0000000'

Extra Test:

score: 0
Extra Test Passed