发现这个说的比较通俗：
假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7，可以看出来它的LIS长度为5。
下面一步一步试着找出它。
我们定义一个序列B，然后令 i = 1 to 9 逐个考察这个序列。
此外，我们用一个变量Len来记录现在最长算到多少了
首先，把d[1]有序地放到B里，令B[1] = 2，就是说当只有1一个数字2的时候，长度为1的LIS的最小末尾是2。这时Len=1
然后，把d[2]有序地放到B里，令B[1] = 1，就是说长度为1的LIS的最小末尾是1，d[1]=2已经没用了，很容易理解吧。这时Len=1
接着，d[3] = 5，d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5，就是说长度为2的LIS的最小末尾是5，很容易理解吧。这时候B[1..2] = 1, 5，Len＝2
再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适，因为1小于3，长度为1的LIS最小末尾应该是1，这样很容易推知，长度为2的LIS最小末尾是3，于是可以把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2
继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6, 这时B[1..3] = 1, 3, 6，还是很容易理解吧？ Len = 3 了噢。
第6个, d[6] = 4，你看它在3和6之间，于是我们就可以把6替换掉，得到B[3] = 4。B[1..3] = 1, 3, 4， Len继续等于3
第7个, d[7] = 8，它很大，比4大，嗯。于是B[4] = 8。Len变成4了
第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大，到5了。
最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道，最新的B[4] =7，B[1..5] = 1, 3, 4, 7, 9，Len = 5。
于是我们知道了LIS的长度为5。
!!!!! 注意。这个1,3,4,7,9不是LIS，它只是存储的对应长度LIS的最小末尾。有了这个末尾，我们就可以一个一个地插入数据。虽然最后一个d[9] = 7更新进去对于这组数据没有什么意义，但是如果后面再出现两个数字 8 和 9，那么就可以把8更新到d[5], 9更新到d[6]，得出LIS的长度为6。
然后应该发现一件事情了：在B中插入数据是有序的，而且是进行替换而不需要挪动——也就是说，我们可以使用二分查找，将每一个数字的插入时间优化到O(logN)~~~~~于是算法的时间复杂度就降低到了O(NlogN)～
还有一个严格证明的，都很不错：
设 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[x] < A[y] < A[t] (3)F[x] = F[y]
此时，选择F[x]和选择F[y]都可以得到同样的F[t]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？
很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[t-1]这一段中，如果存在A[z]，A[x] < A[z] < a[y]，则与选择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，则有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[]在算法结束后记录的并不是一个符合题意的最长上升子序列！
1 #include <iostream>
2 using namespace std;
3 int find(int *a,int len,int n)//若返回值为x,则a[x]>=n>a[x-1]
4 {
5 int left=0,right=len,mid=(left+right)/2;
6 while(left<=right)
7 {
8 if(n>a[mid]) left=mid+1;
9 else if(n<a[mid]) right=mid-1;
10 else return mid;
11 mid=(left+right)/2;
12 }
13 return left;
14 }
15
16 void fill(int *a,int n)
17 {
18 for(int i=0;i<=n;i++)
19 a[i]=1000;
20 }
21
22 int main(void)
23 {
24 int max,i,j,n,a[100],b[100],c[100];
25 while(cin>>n)
26 {
27 fill(c,n+1);
28 for(i=0;i<n;i++)
29 cin>>a[i];
30 c[0]=-1;// …………………………………1
31 c[1]=a[0];// …………………………2
32 b[0]=1;// …………………………………3
33 for(i=1;i<n;i++)// ………………4
34 {
35 j=find(c,n+1,a[i]);// …………………5
36 c[j]=a[i];// ………………………………6
37 b[i]=j;//……………………………………7
38 }
39 for(max=i=0;i<n;i++)// ………………………8
40 if(b[i]>max)
41 max=b[i];
42 cout<<max<<endl;
43 }
44 return 0;
45 }
对于这段程序，我们可以用算法导论上的loop invariants来帮助理解.
loop invariant :
1、每次循环结束后c都是单调递增的。(这一性质决定了可以用二分查找）
2、每次循环后，c[i]总是保存长度为i的递增子序列的最末的元素，若长度为i的递增子序列有多个，刚保存末尾元素最小的那个.（这一性质决定是第3条性质成立的前提） 3、每次循环完后，b[i]总是保存以a[i]结尾的最长递增子序列。
initialization:
1、进入循环之前，c[0]=-1,c[1]=a[0],c的其他元素均为1000,c是单调递增的;
2、进入循环之前，c[1]=a[0],保存了长度为1时的递增序列的最末的元素，且此时长度为1 的递增了序列只有一个，c[1]也是最小的; 3、 进入循环之前，b[0]=1，此时以a[0]结尾的最长递增子序列的长度为1.
maintenance:
1、若在第n次循环之前c是单调递增的，则第n次循环时，c的值只在第6行发生变化，而由 c进入循环前单调递增及find函数的性质可知（见find的注释), 此时c[j+1]>c[j]>=a[i]>c[j-1],所以把c[j]的值更新为a[i]后，c[j+1]>c[j]> c[j-1]的性质仍然成 立，即c仍然是单调递增的；
2、循环中，c的值只在第6行发生变化，由c[j]>=a[i]可知，c[j]更新为a[i]后，c[j]的值只会变 小不会变大，因为进入循环前c[j]的值是最小的，则循环中把c[j]更新为更小的a[i]，当 然此时c[j]的值仍是最小的;
3、循环中，b[i]的值在第7行发生了变化，因为有loop invariant的性质2，find函数返回值 为j有：c[j-1]<a[i]<=c[j],这说明c[j-1]是小于a[i]的，且以c[j-1]结尾的递增子序列有最大的 长度，即为j-1,把a[i]接在c[j-1]后可得到以a[i]结尾的最长递增子序列，长度为(j-1)+1=j;
termination:
循环完后，i=n-1,b[0],b[1],...,b[n-1]的值均已求出，即以a[0],a[1],...,a[n-1]结尾的最长递 增子序列的长度均已求出，再通过第8行的循环，即求出了整个数组的最长递增子序列。
仔细分析上面的代码可以发现，每次循环结束后，假设已经求出c[1],c[2],c[3],...,c[len]的值，则此时最长递增子序列的长度为 len,因此可以把上面的代码更加简化，即可以不需要数组b来辅助存储，第8行的循环也可以省略。
1 #include <iostream>
2 #include <cstdio>
3
4 using namespace std;
5
6 int poor[500008],Update[500008];
7 int main()
8 {
9 int a,b,n,len,high,low,mid,cal=1;
10 while(scanf("%d",&n)!=EOF)
11 {
12 for(int i=1;i<=n;i++) {scanf("%d%d",&a,&b);poor[a]=b;}
13 len=1;Update[1]=poor[1];
14 for(int i=1;i<=n;i++)
15 {
16 low=1;high=len;
17 while(low<=high)
18 {
19 mid=(low+high)/2;
20 if(Update[mid]>=poor[i]) high=mid-1;
21 else low=mid+1;
22 }
23 Update[low]=poor[i];
24 if(low>len) len++;
25 }
26 printf("Case %d:\n",cal++);
27 if(len>1) printf("My king, at most %d roads can be built.\n\n",len);
28 else printf("My king, at most 1 road can be built.\n\n");
29 }
30 return 0;
31 }
LIS问题---HDU1025 Constructing Roads In JGShining's Kingdom,布布扣,bubuko.com
LIS问题---HDU1025 Constructing Roads In JGShining's Kingdom