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;
}