九度oj 题目1533：最长上升子序列

题目描述：

给定一个整型数组， 求这个数组的最长严格递增子序列的长度。 譬如序列1 2 2 4 3 的最长严格递增子序列为1，2，4或1，2，3.他们的长度为3。

输入：

输入可能包含多个测试案例。
对于每个测试案例，输入的第一行为一个整数n(1<=n<=100000)：代表将要输入的序列长度
输入的第二行包括n个整数，代表这个数组中的数字。整数均在int范围内。

输出：

对于每个测试案例，输出其最长严格递增子序列长度。

样例输入：

4
4 2 1 3
5
1 1 1 1 1

样例输出：

2
1

这个题一开始用最简单的办法来做，果然超时了
代码如下

 #include <cstdio>
 int toDo[];
 int cnt[];

 int n;
 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo[i]);
         }
         int max = ;
         for(int i = ; i < n; i++) {
           int maxi = ;
           for(int j = i-; j >= ; j--) {
               if(toDo[j] < toDo[i] && maxi < cnt[j]) {
                 maxi = cnt[j];
               }
           }
           cnt[i] = maxi + ;
           if(max < cnt[i]) {
             max = cnt[i];
           }
         }
         printf("%d\n",max);
     }
     return ;
 }

后来参考了许多别人的博客，才明白应该这样做

首先，你需要一个数组minNum[i]来记录达到长度i的最小数字是几，这个数组必然是递增的，因为长度更长的它的数字肯定更大。

那么，当一个新数字来的时候，假设现在最长的长度为k

如果它比minNum[k]大，那么minNum[++k] = newNum;

如果不比minNum[k]大，则需要去更新这个数组中的元素。具体需采用二分法来找到这个数字的位置，接着更新之。

但一开始提交错误，原来的代码是这样的

 #include <cstdio>
 int toDo[];
 int minNum[];

 int n;

 int bSearch(int p,int low, int high) {
     if(low < high) {
         int mid = (low + high)/;
         if(minNum[mid] == p) {
           return mid;
         }
         else if(minNum[mid] < p) {
           return bSearch(p, mid+, high);
         }
         else {
           return bSearch(p, low, mid-);
         }
     }
     return low;
 }

 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo[i]);
         }

         minNum[] = toDo[];
         int k = ;
         for(int i = ; i < n; i++) {
             if(toDo[i] > minNum[k]) {
                 minNum[++k] = toDo[i];
             }
             else {
                 int p = bSearch(toDo[i], , k);
                 minNum[p] = toDo[i];
             }
         }
         printf("%d\n",k);
     }
     return ;
 }

经过实验，发现测试数据为 4 5 6 1 2 3 5就会出错，

检查之后发现是二分搜索的错误，当minNum为 1 5 6时, 2 的到来使它变为2 5 6, 而不是1 2 6

修改在17行

代码如下

 #include <cstdio>
 int toDo[];
 int minNum[];

 int n;

 int bSearch(int p,int low, int high) {
     if(low < high) {
         int mid = (low + high)/;
         if(minNum[mid] == p) {
           return mid;
         }
         else if(minNum[mid] < p) {
           return bSearch(p, mid+, high);
         }
         else {
           return bSearch(p, low, mid);
         }
     }
     return low;
 }

 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo[i]);
         }

         minNum[] = toDo[];
         int k = ;
         for(int i = ; i < n; i++) {
             if(toDo[i] > minNum[k]) {
                 minNum[++k] = toDo[i];
             }
             else {
                 int p = bSearch(toDo[i], , k);
                 minNum[p] = toDo[i];
             }
         }
         printf("%d\n",k);
     }
     return ;
 }

事实上，不需要toDo这个数组，代码如下

 #include <cstdio>
 int toDo;
 int minNum[];
 int n;

 int bSearch(int p,int low, int high) {
     if(low < high) {
         int mid = (low + high)/;
         if(minNum[mid] == p) {
           return mid;
         }
         else if(minNum[mid] < p) {
           return bSearch(p, mid+, high);
         }
         else {
           return bSearch(p, low, mid);
         }
     }
     return low;
 }

 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         int k = ;
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo);
           if(k == ) {
              minNum[++k] = toDo;
              continue;
           }
           if(toDo > minNum[k]) {
                 minNum[++k] = toDo;
             }
             else {
                 int p = bSearch(toDo, , k);
                 minNum[p] = toDo;
             }
         }
         printf("%d\n",k);
     }
     return ;
 }

今天看书，知道有个函数是lower_band(), upper_band(),fill();

需要#include <algorithm>

using namespace std

lower_band()从已排好序的序列a中利用二分搜索(区间左开右闭)找出指向满足ai>=k的ai的最小指针

lower_band(a, a+n, k)

可以写出如下代码

 #include <cstdio>
 #include <algorithm>
 using namespace std;
 int toDo;
 int dp[];
 int n;

 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         int k = ;
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo);
           if(k == ) {
             dp[k++] = toDo;
           }
           else {
             int *p = lower_bound(dp,dp+k,toDo);
             if(p - dp == k) {
               dp[k++] = toDo;
             }
             else {
               *p = toDo;
             }
           }

         }

         printf("%d\n",k);
     }
     return ;
 }

甚至是

 #include <cstdio>
 #include <algorithm>
 #define inf 2147483647
 using namespace std;
 int toDo;
 int dp[];
 int n;

 int main(int argc, char const *argv[])
 {
     while(scanf("%d",&n) != EOF) {
         int k = ;
         fill(dp, dp+n,inf);
         for(int i = ; i < n ; i++) {
           scanf("%d",&toDo);
           *lower_bound(dp,dp+n,toDo) = toDo;
         }

         printf("%d\n",lower_bound(dp, dp+n, inf) - dp);
     }
     return ;
 }