cf1478C Nezzar and Symmetric Array

最新推荐文章于 2022-01-05 15:29:17 发布

原创最新推荐文章于 2022-01-05 15:29:17 发布 · 453 阅读

1 ·

CC 4.0 BY-SA版权

cf 专栏收录该内容

7 篇文章

订阅专栏

该博客探讨了一个数学问题，涉及寻找一个由2n个不同整数组成的对称数组，使得每个元素与其他所有元素的绝对值之差的和等于给定的值。通过分析和排序输入数据，提出了一个解决此问题的算法，该算法检查是否存在满足条件的对称数组。文章以样例解释了思路，并给出了代码实现。

Long time ago there was a symmetric array a1,a2,…,a2n consisting of 2n distinct integers. Array a1,a2,…,a2n is called symmetric if for each integer 1≤i≤2n, there exists an integer 1≤j≤2n such that ai=−aj.

For each integer 1≤i≤2n, Nezzar wrote down an integer di equal to the sum of absolute differences from ai to all integers in a, i. e. di=∑2nj=1|ai−aj|.

Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.

Input
The first line contains a single integer t (1≤t≤105) — the number of test cases.

The first line of each test case contains a single integer n (1≤n≤105).

The second line of each test case contains 2n integers d1,d2,…,d2n (0≤di≤1012).

It is guaranteed that the sum of n over all test cases does not exceed 105.

Output
For each test case, print “YES” in a single line if there exists a possible array a. Otherwise, print “NO”.

You can print letters in any case (upper or lower).

Example
inputCopy
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
outputCopy
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,−3,−1,3] is one possible symmetric array that generates the array d=[8,12,8,12].

In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
题意
有2n个整数，每个数各不相同，且对于其中的任意数总能找到他的相反数，给你每个数与其他所有数的绝对值之差的和，问你能不能还原出原来的数
思路
我们先从样例中给的两个YES的输入着手，会发现每个数在输入中都会出现两次，进一步的思考，我们可以很快的发现，由于|A-B|与|-A-(-B)|一定是相等的，对于任意d[i]存在与之相同的数。由此可以找出第一个规律：

输入中的每个数出现且仅出现2次

我们先从最简单的数据开始找规律
假如我们有4个数，分别为a,b,-a,-b,那么对于第一个数
在这里插入图片描述
我们假设a,b均为正数，
此时d有两种情况

并且d1>d2的
由此我们可以想到，我们完全可以将输入的d从大到小排序并除重，此时d1最大，即为2*n个第一个原数组：2n*a[1]

对于除a[1]外的任意数字（只看正数）都比其小，故的d[1]=n*2a[1]

对于d2，其应当为a[2]计算得到的:2a[1]+(n-1)*2a[2]

对于a[2]，只有a[1]比他大，其他数字均比其小

由此我们就可以推出公式了
在用最后一个样例举一个例子
在这里插入图片描述
代码

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <map>
const int inf=0x3f3f3f3f;
#define ll long long
#define ull unsigned long long
#define mm(w,v) memset(w,v,sizeof(w))
#define f(x,y,z) for(int x=(y),_=(z);x<_;++x)
const int modn=1e9+7;
const int MAXN=1000000;
using namespace std;
ll ans[100000+10];
ll d[100000+10];
map<ll,int> hs; 
bool cmp(ll a,ll b) {
	return a>b;
}
void solve() {
	int t;
	scanf("%d",&t);
	while(t--) {
		hs.clear();
		int n;
		scanf("%d",&n);
		int cnt=0;
		f(i,0,2*n) {
			ll ip;
			scanf("%lld",&ip);
			if(hs[ip]==0) {
				d[cnt++]=ip;
				hs[ip]=1;
			}
			else {
				hs[ip]++;
			}
		}
		sort(d,d+cnt,cmp);
		bool ok=true;
		ll pre=0;
		int preneed=0;
		for(int i=0;i<cnt;i++) {
			if(hs[d[i]]!=2) {
				ok=false;
				break;
			}
			ll need=n*2;
			if(preneed==0) {
				f(j,0,i) {
					d[i]-=2*ans[j];
					pre+=2*ans[j];
					preneed+=2;
					need-=2;
				}
			}
			else {
				d[i]-=(pre+2*ans[i-1]);
				pre+=2*ans[i-1];
				need-=(preneed+2);
				preneed+=2;
			}
			if(d[i]%need!=0||d[i]<=0) {
				ok=false;
				break;
			}
			ans[i]=d[i]/need;
			if(i>0&&ans[i]>=ans[i-1]) {
				ok=false;
				break;
			}
		}
		if(ok) {
			printf("YES\n");
		}
		else {
			printf("NO\n");
		}
	}
}
int main(void) {
	solve();
}