lis算法

1. LIS（最长上升子序列）的O（nlogn）算法

对于计算中获得的递增序列A1A2A3...Am ，每个At其实表示：之前出现的所有序列中，长度t的上升子序列末位最小为At。对于出现的下一个新元素An，需要更新子序列，如果Amin+1>An>Amin，说明长度为min+1的子序列最后一个元素可以更新为An；如果An>Am，说明可获得的最长子序列可更新为A1A2A3..Am An 。
这么去理解会容易些。

2. LIS算法的O(n^2)算法分析

（a[1]...a[n] 存的都是输入的数）
1、对于a[n]来说，由于它是最后一个数，所以当从a[n]开始查找时，只存在长度为1的不下降子序列；
2、若从a[n-1]开始查找，则存在下面的两种可能性：
（1）若a[n-1] < a[n] 则存在长度为2的不下降子序列 a[n-1],a[n].
（2）若a[n-1] > a[n] 则存在长度为1的不下降子序列 a[n-1]或者a[n]。
3、一般若从a[t]开始，此时最长不下降子序列应该是按下列方法求出的：
在a[t+1],a[t+2],...a[n]中，找出一个比a[t]大的且最长的不下降子序列，作为它的后继。
4、为算法上的需要，定义一个数组：
d:array [1..n,1..3] of integer;
d[t,1]表示a[t]
d[t,2]表示从i位置到达n的最长不下降子序列的长度
d[t,3]表示从i位置开始最长不下降子序列的下一个位置
最长不下降子序列的O(n*logn)算法
先回顾经典的O(n^2)的动态规划算法，设A[t]表示序列中的第t个数，F[t]表示从1到t这一段中以t结尾的最长上升子序列的长度，初始时设F[t] = 0(t = 1, 2, ..., len(A))。则有动态规划方程：F[t] = max{1, F[j] + 1} (j = 1, 2, ..., t - 1, 且A[j] < A[t])。
现在，我们仔细考虑计算F[t]时的情况。假设有两个元素A[x]和A[y]，满足
(1)x < y < t (2)A[y] < A[x] < A[t] (3)F[x] = F[y]
此时，选择A[x]和选择A[y]都可以得到同样的F[t]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？
很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[t-1]这一段中，如果存在A[z]，A[y] < A[z] < A[x]，则与选择A[x]相比，选择A[y]将会得到更长的上升子序列。
再根据条件(3)，我们会得到一个启示：根据F[]的值进行分类。对于F[]的每一个取值k，我们只需要保留满足F[t] = k的所有A[t]中的最小值。设D[k]记录这个值，即D[k] = min{A[t]} (F[t] = k)。
注意到D[]的两个特点：
(1)D[k]的值是在整个计算过程中是单调不上升的。
(2)D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。
利用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[t]与D[len]。若A[t] > D[len]，则将A[t]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = A[t]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < A[t]。令k = j + 1，则有D[j] < A[t] <= D[k]，将A[t]接在D[j]后将得到一个更长的上升子序列，同时更新D[k] = A[t]。最后，len即为所要求的最长上升子序列的长度。
在上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法的时间复杂度下降为O(nlogn)，有了非常显着的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！
这个算法还可以扩展到整个最长子序列系列问题，整个算法的难点在于二分查找的设计，需要非常小心注意。

3. LIS算法的介绍

LIS（Longest Increasing Subsequence）最长上升（不下降）子序列，有两种算法复杂度为O(n*logn)和O(n^2)。在上述算法中，若使用朴素的顺序查找在D1..Dlen查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来算法相比没有任何进步。但是由于D的特点(2)，在D中查找时，可以使用二分查找高效地完成，则整个算法时间复杂度下降为O(nlogn)，有了非常显着的提高。需要注意的是，D在算法结束后记录的并不是一个符合题意的最长上升子序列！算法还可以扩展到整个最长子序列系列问题。

4. lis系统是怎么实现解析算法的

BSLIS对检验仪器的数据采集主要通过串行口通讯、USB端口通讯、TCP/IP通讯、定时监控数据库和手工录入等几种方法。
串行口通讯最为普遍，采用RS-232C标准，一般的仪器都支持此标准。

5. LIS的序列

最长上升子序列
Longest Increasing Subsequence
最长上升子序列：
有两种基本方法：两个时间复杂度分别为O(n^2)和O(nlogn) 对于给定数列a，元素个数为n，f[i]为以元素i结尾的最长子上升序列的最大长度。
最长上升子序列f满足对任意1<=j<i<=n(a[j]<a[i])，有f[j]<f[i]。
容易得出O(n^2)的DP状态转移方程：
f[i]=max{f[j]}+1;(1<=j<i且a[j]<a[i])
我们不妨把f的初值设为0，并在末尾添加一个元素inf，并将n++
这样经过两重循环，f[n]即为LIS长度
代码如下： #include<algorithm>#include<cstdio>#defineinf1<<30usingnamespacestd;intn,a[5000],f[5000];intmain(void){inti,j,k;scanf("%d",&n);for(i=1;i<=n;i++)scanf("%d",a+i);a[++n]=inf;for(i=1;i<=n;i++)for(j=1;j<i;j++)if(a[i]>a[j])f[i]=max(f[i],f[j]+1);printf("%d",f[n]);return0;} 又称作CMI算法
时间复杂度为O(nlogn)
其操作如下：
开辟一个栈b，每次取栈顶元素s和读到的元素a做比较，如果a>s，则置为栈顶；如果a<s，则二分查找栈中的比a大的第1个数，并替换。最终栈的大小即为最长递增子序列为长度
考察b栈内每个元素的含义,b[i] 表示所有长度为i的上升子序列中最小的最后一个数.
·举例：原序列为3，4，5，2，4，2
栈为3，4，5，此时读到2，则用2替换3，得到栈中元素为2，4，5，再读4，用4替换5，得到2，4，4，再读2，得到最终栈为2，2，4,最终得到的解是:
长度为1的上升子序列中最小的最后一个数是2 (2)
长度为2的上升子序列中最小的最后一个数是2 (2,2)长度为3的上升子序列中最小的最后一个数是4 (3,4,4)
可知没有长度为4的上升子序列,最长递增子序列长度为3. (3,4,4)
CMI本质是LIS问题的另一种动态规划思路
注意:CMI只能求LIS的长度和最后一个数,不能求LIS的序列!
代码如下：
#include<iostream>
using namespace std;
int n;
int a[1001],b[1001];
int rear;
int solve(int t)
{ int l=1,r=rear;
while(l<=r)
{ int mid=(l+r)>>1;
if(b[mid]>=t)//若为非递减序列，则为b[mid]>t
r=mid-1;
else
l=mid+1;
}
if(l>rear)
rear=l;
return l;
}
int main()
{ int i,j;
scanf("%d",&n);
rear=0;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
b[solve(a[i])]=a[i];
}
printf("%d ",rear);
system("pause");
return 0;
}

6. LIS算法的c代码复杂度为O(nlgn)的如下：

#include<stdio>#defineSIZE100/*b:栈中元素s:待查找元素length:栈中元素个数*/intdichotomy_search(int*b,ints,intlength){intlow=0,between=0;while(low<length){between=(low+length)/2;if(b[between]>s)length=between-1;elselow=between+1;}returnlow;}intLIS(int*a){intstack[SIZE],j=0;stack[j]=a[0];for(inti=1;i<SIZE;i++){if(a[i]>stack[i-1]){stack[j++]=a[i];}elseif(a[i]<stack[i-1]){intn=dichotomy_search(stack,a[i],j+1);stack[n]=a[i];}}returnj;}

7. C++中容器list的问题

因为你在删除最后一个元素89后，iter2指向end()，之后又对iter2自增，所以引发错误，可以这样修改循环：
while(iter2 != lis.end() ) {
iter2 = lis.erase(iter2);
if(iter2 != lis.end() ) {
++iter2;
}
}