每日一题(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;
}