比如CSDN的积分形式（以下为假设），每当你获得一次积分，服务器便保留这时的时间以及总分。
现在要求在哪一段时间内获得积分的效率最高（前提这段时间内最少获得100分）。求一个时间复杂
度低于n^2的算法。除了穷举的算法O（n^2)，有没有时间复杂度更低的算法呢？

以二维数组模拟以上问题（以下为一个例子）

时间 总分
0 0
10 5
30 28
44 71
99 97
110 105
125 120
198 181
203 190
230 201

时间和总分都是严格递增的。
效率计算方法举例：比如在时间段30到110之间的效率为（105-28）/（110-30）。

积分是以时间点为单位获得的。
比如，如果input为：
0 0
5 10
10 20
20 100

实际上的获得积分的情况为：
0 0
5 10
10 10
20 80 （在这一点获得了80分）

定义 slope = 在单位时间内获得的最大积分，那么明显在 5~20区间内，slope最大，为：100/(20-5) = 6.67。

但题目给的理解方式为，积分差 = A时间点得分 - B时间点得分；所以依照这个方法计算，slope = 100/（20-0）= 5；
这实际上是从一个得了分的时间点之后开始算的，但没有算这个时间点的得分（就是说，多算了A时间点之后到A之后第一次得
分之前的时间）。
明显这样的计算方式并不能算出最大的slope。

input:
若干行 以 time,score 形式的数据，其中time表示一个时间点，score表示在这个时间点的累积得分；time、score均严格递增。

output：
end,start;
其中end，start的意义为:
定义 Δslope = (time[i] - time[j])/(score[i]-score[j])；
end,start满足：
1. score[end] - score[start] >= score interval  (这里题目给的是100)
2. Δslope = (time[end]-time[start])/(score[end]-score[start]) 的值为最大。

这个方法的time complexity: O(n) ~~~

为了思考方便，首先我做了一个坐标系的转化：
把time看成纵坐标（y轴），score看成横坐标（x轴）；这样问题转化为，求在Δscore （即Δx
）>= 100 （为了一般性，我在代码里面用scoreInterval表示这个数字）的时候，使得slope最
小的 startIndex 和 endIndex。
假设一共输入了n组数据。（代码中的 score.size()等价于n）

*****************************preprocess***************************************
建立两个表：predecessor[n]， minSlopeStartIndexTable[n];
第一个表，predecessor[i]表示：
对于index i，startIndex = predecessor[i]是i之前的第一个使得 Δscore = score
[i] - score[startIndex] >= scoreInterval 的 startIndex。对应的建表方法见code。这步
需要 O(n)的时间。

第二个表，minSlopeStartIndexTable[n]表示：
对于index i，假设 sIndex = minSlopeStartIndexTable[i]，那么 对于j = 从index
0开始，到index i，使得 所有终结于i的点中，slope(j,i)的值为最小的，记为sIndex，存储
在这个表中。
易知递归关系有：
minSlopeStartIndexTable[i] =
(slope(minSlopeStartIndexTable[i-1],i)<slope(i-1,i))?
minSlopeStartIndexTable[i-1]:i-1;
这一步需要O(n)的时间。

*****************************calculation***************************************
于是我们开始进行计算：
保持一个minSlope：这是进行到当前计算状态中，能得到的最小的slope。初始化为正无穷
（INF，一个非常大的数值）
同时有bestStartIndex，bestEndIndex表示对应minSlope的两个index。

对于index i：
假设：minSlope是从0~i-1中所有可能中的最小斜率。
首先我们需要计算从predecessor[i]到i的斜率，同minSlope比较；
然后考虑predecessor[i]之前的最小的斜率（即从 minSlopeStartIndexTable
[predecessor[i]] 到 predecessor[i]的斜率），如果比（predecessor[i] 到i 的斜率）要小
，那么他们合起来的斜率是一个比predecessor[i]到i的斜率更小的斜率。所以，我们用这个和
minSlope比较。
在以上比较进行完成之后，可以保证 minSlope 是从 0~i中所有可能中的最小斜率。
每次对 index i的比较需要 O(1)的时间，一共进行n次，所以也是O(n)的时间。

*****************************Test Case***************************************
另外，为了测试方便，给出Test Case：
（测试的人把code里面的freopen、结尾的while(1)取消注释就好了；同时建立测试文件
MaxSlopeOverInterval_in.txt，保存在和这个code的相同目录下）

#include <iostream>
#include <vector>

#define INF 1000000000
using namespace std;

vector<int> timePoint, score;
int scoreInterval = 100; // by default the score interval is 100

double slope(int startIndex,int endIndex){
return ((double)(timePoint[endIndex] - timePoint[startIndex]))/(
score[endIndex] - score[startIndex]);
}

int main(){
// freopen("MaxSlopeOverInterval_in.txt","r",stdin);

// handle the input
int t,p;
while(scanf("%d%d",&t,&p)!=EOF){
timePoint.push_back(t);score.push_back(p);
}

for(int i=0;i<score.size();i++){
printf("%d: %d, %d\n",i,timePoint[i],score[i]);
}

// preporcessing:
// *1. store the predecessor of score[i]
int predecessor[score.size()]; int predecessorIndex = 0;
for(int i=0;i<score.size();i++){
if(score[i]<scoreInterval) predecessor[i] = -1;
else{
while(score[i] - score[predecessorIndex + 1] >= scoreInterval){
predecessorIndex++;
}
predecessor[i] = predecessorIndex;
}
printf("predecessor index of %d: %d\n",i,predecessorIndex);
}
// *2. stores the minSlopeStartIndex from its value to i.
// minSlopeStartIndexTable[i] is the startIndex of the slope, and
// i is the endIndex of the slope, which makes the slope(j,i) to be
// smallest for all j from 0 to i-1
int minSlopeStartIndexTable[score.size()];
minSlopeStartIndexTable[0]=0;minSlopeStartIndexTable[1]=0;
for(int i=2;i<score.size();i++){
minSlopeStartIndexTable[i] =
(slope(minSlopeStartIndexTable[i-1],i)<slope(i-1,i))?
minSlopeStartIndexTable[i-1]:i-1;
printf("%dth minSlope: %d\n",i,minSlopeStartIndexTable[i]);
}

int formerBestStartIndex=0;
// score[i] - score[formerBestStartIndex] is the min for start = 0~i,
// which satisfies score[end] - score[start] > scoreInterval
int bestStartIndex=0,bestEndIndex=0;
// the start and end of the time period with max score/timePeriod gained
double minSlope = INF;

/* basic idea:
to compare (minSlope) and
slope(iScorePredecessorIndex,i), slope(formerBestStartIndex,i)
*/
for(int i=1;i<score.size();i++){
int iScorePredecessorIndex = predecessor[i];
if(iScorePredecessorIndex >= 0){
// compare (minSlope) and slope(islope(iScorePredecessorIndex,i))
printf("slope from %d to %d: %lf\n",iScorePredecessorIndex,i,
slope(iScorePredecessorIndex,i));
if(minSlope > slope(iScorePredecessorIndex,i)){
minSlope = slope(iScorePredecessorIndex,i);
bestStartIndex = iScorePredecessorIndex;
bestEndIndex = i;
}

// compare (minSlope) and slope(formerBestStartIndex,i)
formerBestStartIndex = minSlopeStartIndexTable[predecessor[i]];
printf("%dth element's former Best Start Index: %d, slope = %lf\n",
i,formerBestStartIndex,slope(iScorePredecessorIndex,i));
if(minSlope > slope(formerBestStartIndex,i)){
minSlope = slope(formerBestStartIndex,i);
bestStartIndex = formerBestStartIndex;
bestEndIndex = i;
}
}
}

printf("\n\nThe best one is : start time = %d, end time = %d, slope = %lf\n",
timePoint[bestStartIndex],timePoint[bestEndIndex],1/minSlope);

// while(1);
return 0;
}