题目来源，待字闺中，原创@陈利人 ，欢迎大家继续关注微信公众账号“待字闺中”

原题

给定一个数组，数组中只包含0和1。请找到一个最长的子序列，其中0和1的数量是相同的。

例1：10101010 结果就是其本身。

例2：1101000 结果是110100

请大家展开自己的思路。

分析

这个题目，看起来比较简单，一些同学可能认为题目的描述符合动态规划的特征，然后就开始用动态规划解，努力找状态转移方程。这些同学的感觉，是很正确的。但，找状态转移方程，我们要对原来的数组进行变换一下。

原来是0和1的串，我们将0都换为-1。这样题目目标就变成，找到一个最长的子串，子串数字和是0。设原数组为A, DP[i]表示从0开始到i的子数组和。DP遍历一遍数组即可。例1中的数组产生的DP为：

这个例子，最后一个值是0，并且长度是偶数位。直接满足了结果。

再看例子2：

5的位置为0，最长子串从0开始到5，长度为6。

上面这两个例子，所求的子串都是从头开始，如果不是从头开始，会是什么样的呢？看这个例子：1101100

通过观察上面的表格，我们可以得到，DP[0]==DP[6]==DP[2]，DP[1]==DP[3]. 根据DP的定义，如果DP[i]==DP[j]，i 一种方法，我们用map保存DP的值到位置的映射，如下表：

我们最终的算法，要综合考虑最长串是否从头开始的。 上面的这个思路，时间复杂度是O(n),空间复杂度也是O(n).具体代码如下：

struct node//保存hash表中的最大最小位置
{
	int minIndex;
	int maxIndex;
	node(int a=0,int b=0):minIndex(a),maxIndex(b){}
};
void InsetIntoHashMap(map<int,node>& hashMap,int key,int index)//把”和“及位置插入hash表中
{
	map<int,node>::iterator iter = hashMap.find(key);
	if(iter == hashMap.end())//该和第一次出现
	{
		node value(index,index);
		hashMap.insert(make_pair(key,value));
	}
	else//修改该和的最大最小位置
	{
		if(hashMap[key].minIndex > index ) hashMap[key].minIndex = index;
		else if (hashMap[key].maxIndex < index)hashMap[key].maxIndex = index;
	}
}
vector<int> LongSubSeq(vector<int>& data)
{
	int length = data.size(),i,begin=0,end=0,size = 0;
	vector<int> numbers(length);//把原数组的0转换为1
	vector<int> sum(length,0);//存放到目前为止的和
	for(i=0;i<length;i++)
	{
		if(data[i] == 0)numbers[i] = -1;
		else numbers[i] = 1;
	}
	map<int,node> hashMap;
	node value(-1,-1);
	hashMap[0] = value;//初始化，因为要做差，而第-1个位置相当于是从和为0开始的
	for(i=0;i<length;i++) 
	{
		if(i != 0) sum[i] = sum[i-1] + numbers[i];
		else sum[i] = numbers[i];
		InsetIntoHashMap(hashMap,sum[i],i);
	}
	vector<int> res;
	map<int,node>::iterator iter = hashMap.begin();
	for(;iter != hashMap.end();iter ++)
	{
		if((iter->second).maxIndex - (iter->second).minIndex > size)
		{
			size = (iter->second).maxIndex - (iter->second).minIndex;
			begin = (iter->second).minIndex;
			end = (iter->second).maxIndex;
		}
	}
	res.push_back(begin);//保存开始和结束的位置
	res.push_back(end);
	return res;
}