动态规划-最长单调递增子序列(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 = ;
 int n;
 char a[MAX_N];
 int dp[MAX_N];
 int main() {
     int n;
     cin >> n;
     while(n--) {
         int ans = ;
         fill(dp, dp+MAX_N, );
         cin >> a;
         int len = strlen(a);
         for(int i = ; i < len; i++) {
             for(int j = ; j < i; j++) {
                 if(a[j] < a[i]) dp[i] = max(dp[i], dp[j] + );
             }
             ans = max(ans, dp[i]);
         }
         cout << ans << endl;
     }
     return ;
 }

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 = ;
 const int INF = ;
 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 = ; i < len; i++) {
             for(int j = ; j < len; j++) {
                 if(!i || dp[j] >= a[i])  {
                     dp[j] = a[i]; break;
                 }
             }
         }
         int ans = ;
         while(dp[ans] != INF) ans++;
         cout << ans << endl;
     }
     return ;
 }

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 = ;
 const int INF = ;
 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 = ; i < len; i++) {
             *lower_bound(dp, dp+len, a[i]) = a[i];
         }
         cout << lower_bound(dp, dp+len, INF) - dp << endl;
     }
     return ;
 }