HDU - 1270 小希的数表

题目：

Gardon昨天给小希布置了一道作业，即根据一张由不超过5000的N(3<=N<=100)个正整数组成的数表两两相加得到N*(N-1)/2个和，然后再将它们排序。例如，如果数表里含有四个数1，3，4，9，那么正确答案是4，5，7，10，12，13。小希做完作业以后出去玩了一阵，可是下午回家时发现原来的那张数表不见了，好在她做出的答案还在，你能帮助她根据她的答案计算出原来的数表么？ 

Input包含多组数据，每组数据以一个N开头，接下来的一行有按照大小顺序排列的N*(N-1)/2个数，是小希完成的答案。文件最后以一个0结束。 

假设输入保证解的存在性和唯一性。 

Output对于每组数据，输出原来的数表。它们也应当是按照顺序排列的。 

Sample Input

4
4 5 7 10 12 13
4
5 6 7 8 9 10
0

Sample Output

1 3 4 9
2 3 4 6

对于N个数，有n=N*(N-1)/2个和

这个题目的难点在于，这n个和可能有一些是一样的

首先注意到，n个和中，第一个一定是ans[1]+ans[2]，ans即为要求的答案

第二个和一定是ans[1]+ans[3]

第三个和可能是ans[2]+ans[3]，但是也可能是ans[1]+ans[4]

实际上，ans[2]+ans[3]出现的位置(key)可能是3到N

只要枚举key，就能用方程sum[1]+sum[2]-sum[key]=ans[1]*2求出ans[1]

之所以说是方程，是因为在直接除2之前，需要判断奇偶性

得到了ans[1]之后，就可以算出所有的数

这个过程大致可以总结为：

先求出ans[2]，再add(2)，再求出ans[3]，再add(3)，再求出ans[4]，再add(4)......

add函数是每次求出一个ans[i]之后，把前i-1个数和ans[i]的i-1个和删掉

那么剩下的所有和之中，最小的就是ans[1]+ans[i+1]了，如此即可继续求ans[i+1]

代码：

#include<iostream>
using namespace std;

int N, n, key, sum[5000], ans[101], minn;

int look(int s)	//寻找第一个前缀为s且后缀不为key的sum[i]的i
{
int low = 1, high = n, mid;
while (low < high - 1)
{
mid = (low + high) / 2;
if (sum[mid] / 1000>=s)high = mid;
else low = mid;
}
if (sum[low] / 1000 != s)low = high;
if (sum[low] / 1000 != s)return 0;
while (sum[low] % 1000 == key && low < n && sum[low + 1] / 1000 == sum[low] / 1000)low++;
if (sum[low] % 1000 == key)return 0;
return low;
}

bool add(int d)//新增ans[d]，更新sum
{
for (int i = 1; i<d; i++)
{
int k = look(ans[i] + ans[d]);
if (k == 0)return false;
sum[k] = sum[k] / 1000 * 1000 + key;
}
return true;
}

bool solve(int d)
{
if (d > N)
{
for (int i = 1; i <= N; i++)cout << ans[i] << ((i < N) ? " " : "\n");
return true;
}
while (sum[minn] % 1000 == key)minn++;
ans[d] = sum[minn]/1000 - ans[1];
if (!add(d))return false;
return solve(d + 1);
}

int main()
{
while (cin >> N)
{
if (N == 0)break;
n = N*(N - 1) / 2;
sum[0] = 0;
for (int i = 1; i <= n; i++)
{
cin >> sum[i];
sum[i] *= 1000;
}
for (key = 3; key <= N; key++)
{
if ((sum[1] + sum[2] - sum[key]) / 1000 % 2)continue;
ans[1] = (sum[1] + sum[2] - sum[key]) / 2000;
bool flag = true;
for (int i = 2; i <= key && flag; i++)
{
ans[i] = sum[i - 1]/1000 - ans[1];
if (!add(i))flag = false;
}
if (!flag)continue;
minn = 1;
if (solve(key+1))break;
}
}
return 0;
}