DP——最长上升子序列及其二分优化

数字三角形

我们考虑其中的某一个点，到达该节点的路径只能从左上或者右上的节点到达，以该节点结束的所有路径最大值，为两条路径的最大值加上自己的值，因为每次遍历到一个节点，最大值就可以得到，且层层遍历，转移过程近似线性。

#include <iostream>
using namespace std;

const int N = 510, INF = 1e9;

int n;
int a[N][N];
int f[N][N];

int main()
{
    cin >> n;
    
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= i; j ++) cin >> a[i][j];
    }
    
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 0; j <= i + 1; j ++) f[i][j] = -INF;
    }
    
    f[1][1] = a[1][1];
    
    for(int i = 2; i <= n; i ++)
    {
        for(int j = 1; j <= i; j ++) 
            f[i][j] = max(f[i - 1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);
    }
    
    int res = -INF;
    for(int i = 1; i <= n; i ++) res = max(res, f[n][i]);
    
    cout << res << endl;
    return 0;
}

最长上升子序列

最长上升子序列我们从第一个数开始枚举，每次都将位置$i$之前的所有数枚举，求出小于该数的上升子序列最大值，再加1即为以位置$i$结尾的上升子序列的最大值。
$f[i]$表示以$a[i]$结尾的上升子序列的最大长度，我们每次从$0$~$i-1$遍历，取最大值加一即可，时间复杂度为$O(n^2)$

#include <iostream>
using namespace std;

const int N = 1010;

int a[N], f[N];
int n;

int main()
{
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i];
    
    f[1] = 1;
    for(int i = 2; i <= n; i ++)
    {
        f[i] = 1;
        for(int j = 1; j < i; j ++)
        {
            if(a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
        }
    }
    
    int res = 0;
    for(int i = 1; i <= n; i ++) res = max(res, f[i]);
    
    cout << res << endl;
    return 0;
}

二分优化

我们思考得出，我们的上升子序列长度是递增的，且我们的上升子序列中的数值也是严格递增的，我们可以利用这个信息来优化，我们让$f[i]$来表示上升子序列以长度$i$结尾的最小数字，当$a[i]$大于当前的数字，我们让长度加一，若小于当前最小数字，为了保持单调性，我们需要找到第一个大于$a[i]$的数，并将其更新。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int N = 100010;

int a[N];
int n;

int main()
{
    cin >> n;
    for(int i = 0; i < n; i ++) cin >> a[i];
    
    vector<int> f;

    for(int x : a)
    {
        if(f.empty() || x > f.back()) f.push_back(x);
        else f[lower_bound(f.begin(),f.end(), x) - f.begin()] = x;
    }
    
    cout << f.size() << endl;
    return 0;
}