poj 2533 Longest Ordered Subsequence 最长递增子序列(LIS)

两种算法

1.  O(n^2)

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;

 int a[];
 int dp[];
 int main()
 {
     int n, maxn;
     while(scanf("%d", &n) != EOF)
     {
         maxn = ;
         for(int i = ; i < n; i++)
         {
             scanf("%d", &a[i]);
             dp[i] = ;
             for(int j = ; j < i; j++)
             {
                 if(a[j] < a[i] && dp[j] +  > dp[i])
                     dp[i] = dp[j] + ;
             }
         }
         for(int i=;i<n;i++)
         {
             if(maxn < dp[i])
                     maxn = dp[i];
         }
         printf("%d\n", maxn);
     }
     return ;
 }

2.O(nlog(n))

O(nlogn)的算法关键是它建立了一个数组c[]，c[i]表示长度为i的不下降序列中结尾元素的最小值，用K表示数组目前的长度，算法完成后K的值即为最长不下降子序列的长度。

具体点来讲：

设当前的以求出的长度为K，则判断a[i]和c[k]：

1.如果a[i]>=c[k]，即a[i]大于长度为K的序列中的最后一个元素，这样就可以使序列的长度增加1，即K=K+1,然后现在的c[k]=a[i]；

2.如果a[i]<c[k]，那么就在c[1]...c[k]中找到最大的j,使得c[j]<a[i],然后因为c[j]<a[i]，所以a[i]大于长度为j的序列的最后一个元素，那么就可以更新长度为j+1的序列的最后一个元素，即c[j+1]=a[i]。

算法复杂度的分析：

因为共有n个元素要进行计算；每次计算又要查找n次，所以复杂度是O(n^2)，但是，注意到c[]数组里的元素的单调递增的，所以我们可以用二分法，查找变成了logn次。这样算法的复杂度就变成了O(nlogn)。

 #include<stdio.h>
 #include<string.h>
 #include<iostream>
 using namespace std;
 int a[],dp[],c[],n;

 int bin(int size,int k)
 {
     int l=,r=size;
     while(l<=r)
     {
         int mid=(l+r)/;
         if(k>c[mid]&&k<=c[mid+])
             return mid+;
         else if(k<c[mid])
             r=mid-;
         else
             l=mid+;
     }

 }
 int LIS()
 {
     c[]=a[];
     dp[]=;
     int j,ans=;
     for(int i=;i<=n;i++)
     {
         if(a[i]<=c[])
             j=;
         else if(a[i]>c[ans])
             j=++ans;
         else
             j=bin(ans,a[i]);
         c[j]=a[i];
         dp[i]=j;
     }
     return ans;
 }
 int main()
 {
     while(scanf("%d",&n)!=EOF)
     {
         for(int i=;i<=n;i++)
             scanf("%d",&a[i]);
         printf("%d\n",LIS());
     }
     return ;
 }