QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#102782#5433. Absolute Differenceretcarizy#WA 14ms5832kbC++143.9kb2023-05-03 17:40:522023-05-03 17:40:59

Judging History

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

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2023-05-03 17:40:59]
  • 评测
  • 测评结果:WA
  • 用时:14ms
  • 内存:5832kb
  • [2023-05-03 17:40:52]
  • 提交

answer

#include<bits/stdc++.h>
#define double long double
using namespace std;
const double eps = 1e-9;
int n, m, N, M, numa, numb;
pair<int, int> a[100005], b[100005], A[100005], B[100005];
double ans;
int lena, lenb;
double p3(double x){
	return x * x * x;
}
double p2(double x){
	return x * x;
}
int main(){
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
		scanf("%d%d", &a[i].first, &a[i].second);
	for (int i = 1; i <= m; i++)
		scanf("%d%d", &b[i].first, &b[i].second);
	sort(a + 1, a + 1 + n);
	sort(b + 1, b + 1 + m);
	A[N = 1] = a[1];
	for (int i = 2; i <= n; i++)
		if (a[i].first <= A[N].second)
			A[N].second = max(A[N].second, a[i].second);
	else
		A[++N] = a[i];
	B[M = 1] = b[1];
	for (int i = 2; i <= m; i++)
		if (b[i].first <= B[M].second)
			B[M].second = max(B[M].second, b[i].second);
	else
		B[++M] = b[i];
	for (int i = 1; i <= N; i++){
		lena += A[i].second - A[i].first;
		numa++;
	}
	for (int i = 1; i <= M; i++){
		lenb += B[i].second - B[i].first;
		numb++;
	}
	int k;
	double mid=0, len=0;
	len = 0;
	k = 1;
	for (int i = 1; i <= N; i++){
		while (k <= M && B[k].second < A[i].first){
			if (lenb > eps){
				mid = (mid * len + 0.5 * (B[k].second + B[k].first) * (B[k].second - B[k].first)) / (len + B[k].second - B[k].first);
				len += B[k].second - B[k].first;
			}
			else{
				mid = (mid * len + 0.5 * (B[k].second + B[k].first) * 1) / (len + 1);
				len += 1;				
			}
			k++;
		}
		if (lena > eps && lenb > eps)
			ans += (0.5 * (A[i].first + A[i].second) - mid) * (A[i].second - A[i].first) / lena * len / lenb;
		else{
			if (lena > eps)
				ans += (0.5 * (A[i].first + A[i].second) - mid) * (A[i].second - A[i].first) / lena * len / numb;
			else
				if (lenb > eps)
					ans += (0.5 * (A[i].first + A[i].second) - mid) * 1 / numa * len / lenb;
			else
				ans += (0.5 * (A[i].first + A[i].second) - mid) * 1 / numa * len / numb;
		}
		for (int j=k;B[j].first<=A[i].second&&j<=M;j++)
			if (lena>eps&&lenb>eps){
				int l1=max(A[i].first,B[j].first);
				int r1=min(A[i].second,B[j].second);
				if (B[j].first<=A[i].first) ans+=(0.5*(A[i].first+A[i].second)-0.5*(B[j].first+l1))*(A[i].second-A[i].first)/lena*(l1-B[j].first)/lenb;
				if (B[j].second>=A[i].second) ans+=(0.5*(r1+B[j].second)-0.5*(A[i].first+A[i].second))*(A[i].second-A[i].first)/lena*(B[j].second-r1)/lenb;
				if (B[j].second<A[i].second) ans+=(0.5*(r1+A[i].second)-0.5*(l1+r1))*(A[i].second-r1)/lena*(r1-l1)/lenb;
				if (B[j].first>A[i].first) ans+=(0.5*(l1+r1)-0.5*(A[i].first+l1))*(l1-A[i].first)/lena*(r1-l1)/lenb;
				ans+=(1.0*(p3(r1)-p3(l1))/3-1.0*l1*(p2(r1)-p2(l1))+1.0*l1*l1*(r1-l1))/lena/lenb;
			}else if (lena>eps){
				ans+=(1.0*B[j].first-0.5*(B[j].first+A[i].first))/numb*(B[j].first-A[i].first)/lena;
				ans+=(0.5*(B[j].first+A[i].second)-1.0*B[j].first)/numb*(A[i].second-B[j].first)/lena;
			}else if (lenb>eps){
				ans+=(1.0*A[i].first-0.5*(B[j].first+A[i].first))/numa*(A[i].first-B[j].first)/lenb;
				ans+=(0.5*(B[j].second+A[i].second)-1.0*A[i].first)/numa*(B[j].second-A[i].first)/lenb;				
			}
	}
	len = 0;
	k = M;
	for (int i = N; i >= 1; i--){
		while (k >= 1 && B[k].first > A[i].second){
			if (lenb > eps){
				mid = (mid * len + 0.5 * (B[k].second + B[k].first) * (B[k].second - B[k].first)) / (len + B[k].second - B[k].first);
				len += B[k].second - B[k].first;
			}
			else{
				mid = (mid * len + 0.5 * (B[k].second + B[k].first) * 1) / (len + 1);
				len += 1;				
			}
			k--;
		}
		if (lena > eps && lenb > eps)
			ans += (mid - 0.5 * (A[i].first + A[i].second)) * (A[i].second - A[i].first) / lena * len / lenb;
		else
			if (lena > eps)
				ans += (mid - 0.5 * (A[i].first + A[i].second)) * (A[i].second - A[i].first) / lena * len / numb;
		else
			if (lenb > eps)
				ans += (mid - 0.5 * (A[i].first + A[i].second)) * 1 / numa * len / lenb;
		else
			ans += (mid - 0.5 * (A[i].first + A[i].second)) * 1 / numa * len / numb;
	}
	printf("%.15Lf\n", ans);
	return 0;
}

详细

Test #1:

score: 100
Accepted
time: 3ms
memory: 5764kb

input:

1 1
0 1
0 1

output:

0.333333333333333

result:

ok found '0.333333333', expected '0.333333333', error '0.000000000'

Test #2:

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

input:

1 1
0 1
1 1

output:

0.500000000000000

result:

ok found '0.500000000', expected '0.500000000', error '0.000000000'

Test #3:

score: 0
Accepted
time: 2ms
memory: 5656kb

input:

1 1
-1000000000 1000000000
-1000000000 1000000000

output:

666666666.666666673321743

result:

ok found '666666666.666666627', expected '666666666.666666627', error '0.000000000'

Test #4:

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

input:

1 1
-1000000000 0
0 1000000000

output:

1000000000.000000000000000

result:

ok found '1000000000.000000000', expected '1000000000.000000000', error '0.000000000'

Test #5:

score: 0
Accepted
time: 2ms
memory: 5576kb

input:

1 1
-1000000000 -1000000000
-1000000000 1000000000

output:

1000000000.000000119209290

result:

ok found '1000000000.000000119', expected '1000000000.000000000', error '0.000000000'

Test #6:

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

input:

1 1
-999999999 1000000000
-1000000000 -1000000000

output:

1000000000.500000000000000

result:

ok found '1000000000.500000000', expected '1000000000.500000000', error '0.000000000'

Test #7:

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

input:

1 1
-1000000000 1000000000
-999999999 -999999999

output:

999999999.000000119442120

result:

ok found '999999999.000000119', expected '999999999.000000000', error '0.000000000'

Test #8:

score: 0
Accepted
time: 2ms
memory: 3552kb

input:

1 1
1000000000 1000000000
-1000000000 -1000000000

output:

2000000000.000000000000000

result:

ok found '2000000000.000000000', expected '2000000000.000000000', error '0.000000000'

Test #9:

score: 0
Accepted
time: 2ms
memory: 3580kb

input:

1000 1000
-2175 -2174
-1068 -1065
-1721 -1718
777 834
1162 1169
-3529 -3524
3966 3993
1934 1952
-234 -223
-4967 -4947
8500 8510
5272 5276
-6048 -6033
-34 -22
700 705
-7890 -7886
5538 5543
4114 4126
-9201 -9162
-1521 -1519
-5103 -5100
439 441
993 997
-1684 -1680
-8413 -8404
6724 6728
-3242 -3239
2616...

output:

6717.117145739453729

result:

ok found '6717.117145739', expected '6717.117145739', error '0.000000000'

Test #10:

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

input:

1000 1000
-5010 -4999
-2128 -2113
-5798 -5765
705 713
-3956 -3938
-5308 -5307
6759 6772
-772 -770
-860 -859
2308 2323
-5500 -5500
5140 5177
-6747 -6733
7509 7511
8864 8870
-6382 -6374
1901 1904
-5763 -5760
3019 3027
2962 2963
-314 -301
-222 -203
-726 -724
-62 -58
-1203 -1195
-5216 -5215
-4298 -4292
...

output:

6682.581127471435665

result:

ok found '6682.581127471', expected '6682.581127471', error '0.000000000'

Test #11:

score: 0
Accepted
time: 3ms
memory: 5832kb

input:

1000 1000
770 770
5869 5869
-8786 -8786
7549 7549
-4165 -4165
4023 4023
-9779 -9779
7797 7797
1105 1105
508 508
7653 7653
-359 -359
9393 9393
-9363 -9363
-4160 -4160
-3682 -3682
9409 9409
-8548 -8548
-9908 -9908
-7494 -7494
3751 3751
2326 2326
-3311 -3311
3651 3651
-7663 -7663
5376 5376
-7071 -7071
...

output:

6673.756816891039128

result:

ok found '6673.756816891', expected '6673.756816891', error '0.000000000'

Test #12:

score: 0
Accepted
time: 3ms
memory: 5640kb

input:

1000 1000
-735 -735
-829 -829
-6376 -6376
8558 8558
155 155
5533 5533
8800 8800
-1738 -1738
919 919
52 52
2076 2076
-6911 -6911
139 139
6733 6733
9923 9923
-4619 -4619
-9429 -9429
9902 9902
-5984 -5984
2580 2580
8738 8738
7960 7960
3388 3388
-2689 -2689
7986 7986
2565 2565
-8908 -8908
9359 9359
-434...

output:

6479.384680000000001

result:

ok found '6479.384680000', expected '6479.384680000', error '0.000000000'

Test #13:

score: -100
Wrong Answer
time: 14ms
memory: 5816kb

input:

100 10000
82274 82408
61583 61902
-54304 -54007
-48488 -48316
-92517 -91939
85001 85160
33086 33374
36458 36573
-15785 -11838
93971 94863
50496 53064
-68609 -68302
-91873 -91176
-96937 -96753
9481 9976
83600 83691
17742 18693
55685 56039
56323 57845
88761 90277
22886 23642
30848 31047
-34662 -33470
...

output:

-nan

result:

wrong output format Expected double, but "-nan" found