有两个序列a,b，大小都为n,序列元素的值任意整数，无序；
要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
例如: 
var a=[100,99,98,1,2, 3];
var b=[1, 2, 3, 4,5,40];

 网上对于这道题的描述很多，所以拿来练习练习。最直接了当的方法就是尝试各种组合。当然这种解法的时间复杂度是阶乘，显然不能接受。下面的这个方法可以使时间复杂度降到O(m*n)。m是数组长度，n是两个数组和的中间值。为了让大家更好的理解算法，没有使用hash。所以下面的实现的时间复杂都会略高，但实际上是可以优化为O(m*n)的。我们可以创建一个数组长度为两个数组和的中间值。通过对a,b数组元素遍历添加到该数组对应的值，每次遍历时，将本次遍历的元素添加到自己以及该元素和数组中已有元素的和的位置，这样遍历结束后，我们能够找到最接近中间值的数组。例如题目中的例子，第一次遍历1,将1添加到数组中1的位置。第二次遍历2，2需要添加到2和3的位置，因为2+1=3。这个目的是告诉下一次遍历我们已经有元素的和可以得到3。

struct Node{
	Node* next;
	int value;
};
struct Element
{
	Element* next;
	Node* first;
	int length;

};
struct Item{
	Element* elm;
	int length;
	Element* maxElm;
};
void NearesetArr(int* arr1, int* arr2, int length)
{
	if(NULL == arr1 || NULL == arr2 || length < 1)
	{
		return;
	}
	int sum = 0;
	for(int i = 0; i< length; ++i)
	{
		sum += arr1[i];
		sum += arr2[i];
	}
	int mid = sum / 2;
	Item* items = new Item[mid + 1];
	for(int i = 0; i < mid + 1; ++i)
	{
		items[i].length = 0;
		items[i].elm = NULL;
		items[i].maxElm = NULL;
	}
	for(int i  = 0; i < length; ++i)
	{
		for( int k = mid; k > arr1[i]; --k)
		{
			if(items[k - arr1[i]].length != 0 )
			{
				
				for(int j = 0; j < items[k - arr1[i]].length; ++j)
				{
					if(items[k - arr1[i]].elm->length + 1 <= mid)
					{
						Element* elm = new Element;
						Node* node = new	Node;
						node->value = arr1[i];
						node->next = items[k - arr1[i]].elm->first;
						elm->first = node;
						elm->length = items[k - arr1[i]].elm->length + 1;
						elm->next = items[k].elm;
						items[k].elm = elm;
						++items[k].length;
						if(NULL == items[k].maxElm || items[k].maxElm->length < elm->length)
						{
							items[k].maxElm = elm;
						}
					}
				}
				
				
			}
		}
		Element* elm = new Element;
		Node* node = new	Node;
		node->value = arr1[i];
		elm->first = node;
		elm->length = 1;
		++items[arr1[i]].length;
		elm->next = items[arr1[i]].elm;
		items[arr1[i]].elm = elm;
		if(NULL == items[arr1[i]].maxElm || items[arr1[i]].maxElm->length < elm->length)
		{
			items[arr1[i]].maxElm = elm;
		}
	
		for( int k = mid; k > arr2[i]; --k)
		{
			if(items[k - arr2[i]].length != 0 )
			{
				
				for(int j = 0; j < items[k - arr2[i]].length; ++j)
				{
					if(items[k - arr2[i]].elm->length + 1 <= mid)
					{
						Element* elm = new Element;
						Node* node = new	Node;
						node->value = arr2[i];
						node->next = items[k - arr2[i]].elm->first;
						elm->first = node;
						elm->length = items[k - arr2[i]].elm->length + 1;
						elm->next = items[k].elm;
						items[k].elm = elm;
						++items[k].length;
						if(NULL == items[k].maxElm ||items[k].maxElm->length < elm->length)
						{
							items[k].maxElm = elm;
						}
					}
				}
				
				
			}
		}
		elm = new Element;
		node = new	Node;
		node->value = arr2[i];
		elm->first = node;
		elm->length = 1;
		++items[arr2[i]].length;
		elm->next = items[arr2[i]].elm;
		items[arr2[i]].elm = elm;
		if(NULL == items[arr2[i]].maxElm || items[arr2[i]].maxElm->length < elm->length)
		{
			items[arr2[i]].maxElm = elm;
		}
	}
	for(int i = mid; i>=0; --i)
	{
		if(items[i].length != 0 && items[i].maxElm->length == length)
		{
			Node* node =  items[i].maxElm->first;
			for( int j = 0; j <length; ++j)
			{
				printf("%d, ",node->value);
				node = node->next;
				
			}
			return;
		}
	}

}