UVa Problem 10202 Pairsumonious Numbers （两两之和）

// Pairsumonious Numbers （两两之和）
// PC/UVa IDs: 110508/10202, Popularity: B, Success rate: high Level: 4
// Verdict: Accepted
// Submission Date: 2011-05-29
// UVa Run Time: 0.024s
//
// 版权所有（C）2011，邱秋。metaphysis # yeah dot net
//
// 假设一个数组 A，有 N 项，按从小到大的顺序排列，数组 P，有 n * （n - 1） / 2项，是数组 A 中
// 元素两两之和，也按从小到大的顺序排列，已知数组 P，要求数组 A，这就是本问题的另外一种表示。显而
// 易见，P[0] = A[0] + A[1]，P[1] = A[0] + A[2]，但是对于 P[2] 来说却不一定存在 P[2] =
// A[0] + A[3]，因为有可能 P[2] = A[1] + A[2]。假设知道了 A[0]，则可以知道 A[1] 和 A[2]，
// 从数组 P 中删除 A[0] + A[1]，A[0] + A[2]，A[1] + A[2]，则可以保证剩下的和中最小的是
// A[0] + A[3]，则可以知道 A[3]，再次从数组 P 中删除 A[3] 与 A[0]，A[1]，A[2] 的和，则数组
// P 中最小的和肯定是 A[0] + A[4]，以此计算可得到所有 A 的元素。关键是如何确定 A[0]，由于 P
// 中最小的元素是 P[0] = A[0] + A[1]，若 P[0] 为自然数，则有 0 <= A[0] <= (P[0] / 2)，
// 只需在此范围内枚举 A[0] 的值，最终确定数组 A 其他元素的值，若所有值都能匹配数组 P 中的和，则
// 可将数组 A 内容输出作为一组答案。若和 P[0] 不在自然数的范围，小于 0，则可将所有和加上一个常数
// 来将所有和调整到自然数范围，即：P[X] + （-2） * P[0] 可将数组P中的任意元素 P[X] 调整到自然
// 数范围，只需在结果数组 A 中将每个元素A减去调整值的一半即可，即（-1） * P[0]。
//
// 另外一种确定 A[0] 的方法是，由于知道了 P[0] = A[0] + A[1]，P[1] = A[0] + A[2]，只要知
// 道 A[1] + A[2] 的值，则可由 A[0] = （P[0] + P[1] - A[1] + A[2]） / 2 来确定 A[0] 的
// 值，由于和 A[1] + A[2] 肯定在数组 P 中，只要逐个尝试即可，这样比上面一种方法可以减少尝试的范
// 围，注意到 A[0] + A[1] <= A[1] + A[2]，A[0] + A[2] <= A[1] + A[2]，A[1] + A[2] <=
// A[1] + A[3]，故只需要搜索和数组 P[2] 至 P[N + 1] 即可。

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

bool cmp(int a, int b)
{
return a < b;
}

// smallest 为假定的 A[0]，尝试从此找到所有 A 的元素而不发生冲突。
vector < int > complete_all(int smallest, vector < int > sum)
{
vector < int > parameters;
parameters.push_back(smallest);

while (sum.size())
{
int next = sum[0] - parameters[0];
for (int i = 0; i < parameters.size(); i++)
{
vector < int >::iterator it =
find(sum.begin(), sum.end(), next + parameters[i]);
if (it != sum.end())
sum.erase(it);
else
{
parameters.clear();
return parameters;
}
}

parameters.push_back(next);
}

return parameters;
}

// 用第一种方法，枚举 0 <= A[0] <= (P[0] / 2)。
void find_pairsumonious_numbers_by_first_method(vector < int > sum)
{
// 将和按照从小到大排列。
sort(sum.begin(), sum.end(), cmp);

// 将和调整到自然数范围。
int adjust = 0;
if (sum[0] < 0)
adjust = sum[0] * (-2);
else
adjust = 0;

for (int i = 0; i < sum.size(); i++)
sum[i] += adjust;

bool found = false;
for (int i = 0; i <= (sum[0] / 2); i++)
{
vector < int > answer;
answer = complete_all(i, sum);

if (answer.size())
{
for (int i = 0; i < answer.size(); i++)
{
cout << (answer[i] - adjust / 2);
if (i < (answer.size() - 1))
cout << " ";
}
cout << endl;
found = true;
break;
}
}

if (!found)
cout << "Impossible" << endl;
}

// 用第二种方法，枚举数组 P[2] 至 P[N + 1] 为 A[1] + A[2]。
void find_pairsumonious_numbers_by_second_method(vector < int > sum, int n)
{
// 将和按照从小到大排列。
sort(sum.begin(), sum.end(), cmp);

bool found = false;
for (int i = 2; i <= (n + 1); i++)
{
vector < int > answer;

// 只有当 tmp 为偶数才有可能。
int tmp = sum[0] + sum[1] - sum[i];
if (tmp % 2 == 1)
continue;

answer = complete_all(tmp / 2, sum);

if (answer.size())
{
for (int i = 0; i < answer.size(); i++)
{
cout << answer[i];
if (i < (answer.size() - 1))
cout << " ";
}
cout << endl;
found = true;
break;
}
}

if (!found)
cout << "Impossible" << endl;
}

int main(int ac, char *av[])
{
int n, tmp;
vector < int > sum;

while (cin >> n)
{
int capacity = (n * (n - 1) / 2);	// 和数组元素个数。
int counter = 0;	// 计数器。

sum.clear();	// 清空和数组。

// 读入和。
while (counter++ < capacity)
{
cin >> tmp;
sum.push_back(tmp);
}

// find_pairsumonious_numbers_by_first_method(sum);
find_pairsumonious_numbers_by_second_method(sum, n);
}

return 0;
}