九度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[100002];
int cnt[100002];

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

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

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

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

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

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

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

#include <cstdio>
int toDo[100002];
int minNum[100002];
 
int n;
 
int bSearch(int p,int low, int high) {
    if(low < high) {
        int mid = (low + high)/2;
        if(minNum[mid] == p) {
          return mid;
        }
        else if(minNum[mid] < p) {
          return bSearch(p, mid+1, high);
        }
        else {
          return bSearch(p, low, mid-1);
        }
    }
    return low;
}
 
int main(int argc, char const *argv[])
{
    while(scanf("%d",&n) != EOF) {
        for(int i = 0; i < n ; i++) {
          scanf("%d",&toDo[i]);
        }
 
        minNum[1] = toDo[0];
        int k = 1;
        for(int i = 1; i < n; i++) {
            if(toDo[i] > minNum[k]) {
                minNum[++k] = toDo[i];
            }
            else {
                int p = bSearch(toDo[i], 1, k);
                minNum[p] = toDo[i];
            }
        }
        printf("%d
",k);
    }   
    return 0;
}

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

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

修改在17行

代码如下

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

int n;

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

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

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

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

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

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

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

 今天看书，知道有个函数是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[100002];
int n;

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

甚至是

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

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