数组字符串问题----数组的最长递增子数组

问题：求数组的最长递增子数组的长度。

eg: 输入数组{1,-1,2,-3,4,-5,6,-7},因为最长递增子数组为

1 2 4 6 ,所以返回4.

方法一：

显然如果能穷举所有的递增子数组（不相包含），就可以得到最长的是什么。

假设有一个递增子串的集合，遍历数组的过程中维护这个集合：

索引 元素 子串集合

0 1 1

1 -1 1；-1

2 2 1，2；-1，2

3 -3 1，2；-1，2；-3

4 4 1，2，4；-1，2，4；-3，4

5 -5 1，2，4；-1，2，4；-3，4；-5

6 6 1，2，4，6；-1，2，4，6；-3，4，6；-5，6

7 -7 1，2，4，6；-1，2，4，6；-3，4，6；-5，6;-7

输出4

但问题只要求最长递增子串的长度，不必求字串的内容，可以简化：

我们是这样构造子串的：

当我们读到第三个数2时，只要求出以2结尾的串的最大长度就可以了。这样其后如果是比2大的数字，可在他的长度上递

增，其后是比2小的数与这里的计算结果就不搭了。最后我们求出的是以各个位置的数字结尾的递增字串的对大长度。

其中最大值即为输出。

故得到解结构：

输入pin,第i个数子结尾时，字串的最大长度

longest[i]=max{1,longest[k]} 1<=k<i && pin[k]<pin[i]

故有时间复杂度为O(n^2)的算法1：

int longestA(int* pin,int length)
{
int longest[length];
longest[0]=1;
int max=1;
for(int i=1;i<length;i++)
{
longest[i]=1;
for(int j=0;j<i;j++)
{
if(pin[j]<pin[i] && longest[j]+1>longest[i])
longest[i]=longest[j]+1;
}
if(longest[i]>max)
max=longest[i];
}
return max;

}

方法二：

考虑对其方法一优化，求longset[i]时，遍历了之前所有的longsest结果。我门需要找到的是以小于pin[i]结尾的，长度最大

长的字串。故可以记录这两个量的组合：子串长度---结尾数字，而相同的长度会有不同的尾数字，我门只在意最小的

那个是否<pin[i],小则可以得到更长的子串。故该组合应为：子串长度----结尾数字的最小值。我们将所有组合按

长度从小到大排列，长度最大且结尾数字<pin[i] 的。

算法2时间复杂度仍O(n^2)

int longestB(int* pin,int length)
{
int minTail[length+1];
minTail[1]=pin[0];
int maxlengh=1;

for(int i=1;i<length;i++)
{
int mylength=1;
for(int j=maxlengh;j>=1;j--)
{
if(pin[i]>minTail[j])
{
mylength=j+1;
break;
}
}
if(mylength>maxlengh)
{
minTail[mylength]=pin[i];
maxlengh=mylength;
}
else
{
if(pin[i]<minTail[mylength])
minTail[mylength]=pin[i];
}
}
return maxlengh;
}

方法三：

数组minTail[i] ,表示长度为i的递增子串的最小尾数.

实际上存在如下关系：

如果i<j 那么minTail[i]<minTail[j]

证明：

假设minTail[j]<=minTail[i],则长度j的串中长度为i的子串其尾数必然<minTail[i].这和数组minTail的定义矛盾。

所以可以用二分查找实现在minTail中的查找：

算法复杂读为O(nlongn)

//二分查找，找第一个比n小的。
int halfSearch(int* pin,int nstart,int nend,int n)
{
int mid;
int nlow=nstart;
int nhigh=nend;
while(nhigh>=nlow)                //只有当所有数都大于n时，条件不成立，返回1
{
mid=(nhigh+nlow)/2;
if(pin[mid]<n && ( mid+1>nend||pin[mid+1]>=n))
return mid;                    //只要有小于n的元素就从这里返回
else
if( pin[mid]>=n)
nhigh=mid-1;
else
nlow=mid+1;
}
return 0;
}

int longestC(int* pin,int length)
{
int minTail[length+1];
minTail[1]=pin[0];
int maxlengh=1;

for(int i=1;i<length;i++)
{
int mylength=halfSearch(minTail,1,maxlengh,pin[i])+1;
if(mylength>maxlengh)
{
minTail[mylength]=pin[i];
maxlengh=mylength;
}
else
{
if(pin[i]<minTail[mylength])
minTail[mylength]=pin[i];
}
}
return maxlengh;
}