动态规划-最长单调递增子序列(dp)

最长单调递增子序列

解题思想：动态规划

1.解法1(n2)

　状态：d[i] = 长度为i+1的递增子序列的长度

　状态转移方程：dp[i] = max(dp[j]+1, dp[i]);

   分析：最开始把dp数组初始化为1，然后从前往后考虑数列的元素，对于每个aj，如果a[i] > a[j]，就用dp[i] = max(dp[i], dp[j] + 1)进行更新，再从dp数组中找出最大值即为结果

   举例：abklmncdefg

　　　   dp[0] = 1; dp[1] = 2; dp[2] = 3; dp[3] = 4; dp[4] = 5; dp[5] = 6; dp[7] = 3; dp[8] = 4; dp[9] = 5; dp[10] = 6; dp[11] = 7;  最大值为7

　代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAX_N = 10005;
int n;
char a[MAX_N];
int dp[MAX_N];
int main() {
    int n;
    cin >> n;
    while(n--) {
        int ans = 0;
        fill(dp, dp+MAX_N, 1);
        cin >> a;
        int len = strlen(a);
        for(int i = 0; i < len; i++) {
            for(int j = 0; j < i; j++) {
                if(a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
            }
            ans = max(ans, dp[i]);
        }
        cout << ans << endl;
    }
    return 0;
}

2.解法2(n2)

　状态：d[i] = 长度为i+1的递增子序列中末尾的最小值(不存在就是INF)

　分析：最开始用INF初始化dp数组的值，然后从前往后考虑数列的元素，对于每个aj，如果i = 0或者a[j]  >= a[i]，使得a[j] = a[i]并且break出来，最后第一个dp数组中值为INF的下标即为结果

　举例：abklmncdefg

　　　   a; ab; abk; abkl; abklm; abklmn; abclmn; abcdmn; abcden; abcdef; abcdefg; 第一个INF的下标为7　

　代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAX_N = 10005;
const int INF = 127;
int n;
char a[MAX_N];
char dp[MAX_N];
int main() {
    int n;
    cin >> n;
    while(n--) {
        fill(dp, dp+MAX_N, INF);
        cin >> a;
        int len = strlen(a);
        for(int i = 0; i < len; i++) {
            for(int j = 0; j < len; j++) {
                if(!i || dp[j] >= a[i])  {
                    dp[j] = a[i]; break;
                }
            }
        }
        int ans = 0;
        while(dp[ans] != INF) ans++;
        cout << ans << endl;
    }
    return 0;
}

3.解法3(nlogn)

　分析：思路与解法2一样，但是解法2可以进一步优化，在解法2中dp数组是单调递增的，每次要从头到尾找到第一个大于等于a[i]的值，这是o(n2)的，既然是顺序的可以使用二分查找进行改进，

　　　　这样可以在o(nlogn)时间内求出结果，这里利用到了STL中的lower_bound(dp, dp + n, a[i])，找出dp数组中大于等于a[i]的最小的指针，upper_boundlower_bound(dp, dp + n, a[i])，找出dp数组中大于a[i]的最大的指针

   代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX_N = 10005;
const int INF = 127;
int n;
char a[MAX_N];
char dp[MAX_N];
int main() {
    int n;
    cin >> n;
    while(n--) {
        fill(dp, dp+MAX_N, INF);
        cin >> a;
        int len = strlen(a);
        for(int i = 0; i < len; i++) {
            *lower_bound(dp, dp+len, a[i]) = a[i];
        }
        cout << lower_bound(dp, dp+len, INF) - dp << endl;
    }
    return 0;
}