每日一题(62) - 和为s的连续正整数序列

题目来自剑指Offer

本文参考博文A Lazy Programmer's Footprint和eaglet的思路，在此谢过。

复杂度的分析见A Lazy Programmer's Footprint。

题目：寻找和为s的连续正整数序列。

举例：

和为15的正整数序列：

（1）15

（2）7,8

（3）1,2,3,4,5

（4）4,5,6

本文总结两篇博文的思路，共给出三种思路。

思路（1）：枚举起点 + 枚举区间

具体思路：对于每一个起点nStart，枚举以该起点开始的任意长度的区间，求区间内数字的和。

注意，这里对于每一个区间，终点都是要求的目标和nSum，区间长度为nSum - nStart + 1。

复杂度：O（Sum^2），Sum为要求的和 

代码：

#include <iostream>
#include <assert.h>
using namespace std;

void FindSequence(int nSum)
{
	assert(nSum > 0);
	int nSumTmp = 0;
	for (int i = 1;i <= nSum;i++)
	{
		nSumTmp = 0;
		for (int j = i;j <= nSum;j++)//计算区间[i,j]元素的和
		{
			nSumTmp += j;
			if (nSumTmp > nSum)
			{
				break;
			}
			else if (nSumTmp == nSum)
			{
				for (int t = i;t <= j;t++)
				{
					cout<<t<<" ";
				}
				cout<<endl;
			}
		}
	}
}

int main()
{
	FindSequence(15);//15; 7 8; 1 2 3 4 5; 4 5 6;
	//FindSequence(20);//20; 2 3 4 5 6
	system("pause");
	return 1;
}

缺点：上述思想在枚举以任意起点的任意区间时，区间的终点都是nSum。

其实不必让区间的终点都为nSum，而为nSum / nStart。

分析：如果以nStart为起点的区间（长度为nLen）之和恰好为nSum，此时必有nSum >= nLen * nStart。

转换回来为nLen <= nSum / nStart。

即，以nStart为起点的区间，其区间长度最大为 nSum / nStart。

改进的代码：

void FindSequence(int nSum)
{
	assert(nSum > 0);
	int nSumTmp = 0;
	for (int i = 1;i <= nSum;i++)
	{
		nSumTmp = 0;
		for (int j = i;j < i + nSum/i;j++)//计算以i为起点，区间长度为nSum/i的和
		{
			nSumTmp += j;
			if (nSumTmp > nSum)
			{
				break;
			}
			else if (nSumTmp == nSum)
			{
				for (int t = i;t <= j;t++)
				{
					cout<<t<<" ";
				}
				cout<<endl;
			}
		}
	}
}

思路（2）：枚举起点 + 二分查找终点

具体来说，计算区间和时，可以直接使用等差数列公式nSum = （nStart+ nEnd）/ 2。

当然，我们需要枚举每一个起点nStart，那么我们的重点就是找nEnd。

最直观的方法是以起点nStart开始，把区间[nStart,nSum]中的每一个数都试着做终点。当然很低低效。

优化的方法：可以在区间[nStart,nSum]中使用二分寻找nEnd。

这里根据区间[nStart,nMid]的和 与 nSum的关系确定区间是往左走还是往右走。

复杂度：O（Sum* logSum），Sum为要求的和 

代码：

#include <iostream>
#include <assert.h>
using namespace std;
int BinSearch(int nSum,int nLow,int nHigh)
{
	int nStart = nLow;
	int nSumTmp = 0;
	int nMid = 0;
	while(nLow <= nHigh)
	{
		nMid = (nLow + nHigh) >> 1;
		nSumTmp = ((nStart + nMid) * (nMid - nStart + 1)) >> 1;
		if (nSumTmp == nSum)
		{
			return nMid;
		}
		else if (nSumTmp > nSum)
		{
			nHigh = nMid - 1;
		}
		else
		{
			nLow = nMid + 1;
		}
	}
	return -1;
}

void FindSequence(int nSum)
{
	assert(nSum > 0);
	int nStart = 0;
	int nEnd = 0;
	for (int nStart = 1;nStart <= nSum;nStart++)
	{
		nEnd = BinSearch(nSum,nStart,nSum);//计算区间[nStart,nSum]的和
		if (nEnd != -1)
		{
			for (int i = nStart;i <= nEnd;i++)
			{
				cout<<i<<" ";
			}
			cout<<endl;
		}
	}
}

int main()
{
	//FindSequence(15);//15; 7 8; 1 2 3 4 5; 4 5 6;
	FindSequence(20);//20; 2 3 4 5 6
	system("pause");
	return 1;
}

改进的地方：这里需要改进的地方和思路一改进的地方一样，都是区间终点。

以nStart为起点的区间，区间长度最大为nLen <= nSum / nStart。

改进代码：

void FindSequence(int nSum)
{
	assert(nSum > 0);
	int nStart = 0;
	int nEnd = 0;
	for (int nStart = 1;nStart <= nSum;nStart++)
	{
		nEnd = BinSearch(nSum,nStart,nSum / nStart + nStart - 1);//计算区间长度为nSum / nStart的和
		if (nEnd != -1)
		{
			for (int i = nStart;i <= nEnd;i++)
			{
				cout<<i<<" ";
			}
			cout<<endl;
		}
	}
}

思路（3）直接枚举区间长度

具体来说，根据区间中元素个数，确定区间起点。算是最快的。

方法：这里使用等差数列求和公式nSum = nStart * nCount + nCount * （nCount - 1）/ 2。

这里对公式转换可得：

（1）nSum = nStart * nCount + nCount * （nCount - 1）/ 2

（2）nStart * nCount = nSum - nCount * （nCount - 1）/ 2  

此时我们可以根据公式（2）获得区间的起始位置：

具体而言，看上式子的右边，由于已知nSum，当我们枚举nCount时，即nCount也是已知时，可以直接获得nStart * nCount，继而获得区间的起始位置nStart。

现在还有一个问题，就是在枚举区间时，什么时候终止？这里可不是有1到nSum。

根据公式（2）可知，nSum - nCount * （nCount - 1）/ 2 = nStart * nCount >= nCount成立。

当nCount = 1时，nSum 最大，nStart * nCount最大，继而nStart最大。

随着nCount变大，nSum - nCount * （nCount - 1）/ 2变小，可得nStart * nCount变小，最终总有nStart * nCount < nCount，此时循环终止。

注意：代码还有一处优化，就是在求解区间起点时，首先判断m % nCount是否成立。

复杂度：O(sqrt(Sum))，Sum为要求的和 

代码：

#include <iostream>
#include <assert.h>
using namespace std;

void FindSequence(int nSum)
{
	assert(nSum > 0);
	int nCount = 1;
	int m = nSum - nCount * (nCount - 1) / 2;
	int nStart = 0;
	while (nCount <= m)
	{
		if (m % nCount == 0)
		{
			//确定第一个数
			nStart = m / nCount;
			//输出
			for (int i = nStart;i < nStart + nCount;i++)
			{
				cout<<i<<" ";
			}
			cout<<endl;
		}
		nCount++;
		m = nSum - nCount * (nCount - 1) / 2;
	}
}

int main()
{
	FindSequence(15);//15; 7 8; 1 2 3 4 5; 4 5 6; 
	//FindSequence(20);//20; 2 3 4 5 6
	system("pause");
	return 1;
}