lis最长递增子序列

lis的实现有三种，一种是简单的O(n^2)的dp，第二种是转化为lcs，用原序列排序后得到一个有序的序列，并求两序列的最长公共子序列。这种可以比较方便地打印出答案，复杂度也是O(n^2)。最后是维护一个为某个长度时该长度序列的最后一个数可取的最小值，用了二分查找将复杂度降到O(nlogn)。

//LIS
#include <iostream>
#include <algorithm>
#include <list>
#include <vector>

using namespace std;

int dp[105];

void lis(int *p, int n) {
    memset(dp, 0, sizeof(dp));

    for (int i = 1;i < n;i++) {
        dp[i] = dp[i - 1];
        for (int j = 0;j < i;j++)
            if (p[i] > p[j])dp[i] = max(dp[i], dp[j] + 1);
    }
    cout << dp[n - 1];
}

int d[105][105];
void lcs(int*p, int* q, int m, int n) {//m,n为两个数组的长度

    memset(d, 0, sizeof(d));

    for (int i = 1;i<m + 1;i++)
        for (int j = 1;j < n + 1;j++) {
            if (p[i - 1] == q[j - 1])d[i][j] = d[i - 1][j - 1] + 1;
            else d[i][j] = max(d[i - 1][j], d[i][j - 1]);
        }
}

void print_ans(int* p, int* q, int m, int n) {//lcs的打印
    if (d[m][n] <= 0)return;

    if (d[m][n] == d[m - 1][n - 1] + 1) {
        print_ans(p, q, m - 1, n - 1);
        cout << p[m - 1];
    }
    else if (d[m][n] = d[m - 1][n])
        print_ans(p, q, m - 1, n);
    else
        print_ans(p, q, m, n - 1);
    //cout << endl;
}

int binarysearch(int* a, int len, int val) {
    int left = 0, right = len;//左闭右开
    while (left < right) {
        int mid = (left + right) / 2;
        if (a[mid] > val)
            right = mid;
        else if (a[mid] < val)
            left = mid + 1;
        else
            return mid;
    }
    return left;
}

int lis1(int *p, int n) {
    int *a = new int[n];
    int length = 1;
    a[0] = p[0];

    for (int i = 1;i < n;i++) {
        if (p[i] > a[length - 1])
            a[length++] = p[i];
        else
            a[binarysearch(a, length, p[i])] = p[i];
    }

    delete a;
    return length;
}