最长上升子序列类（应用上）

原题目：最长上升子序列，所有题目，材料均来自于：www.acwing.com


代码：

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 1010;

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

引申到另一个题目：怪盗基德的滑翔翼 acwing 1017


在任意一栋建筑上，选定了一个方向之后就变为求以该节点为终点的最长上升子序列或者以当前为起点的最长下降子序列（反方向上也是最长上升子序列）。
思路：对两个方向上做LIS，取最大值
代码：

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

const int N = 110;
int f[N], a[N];

int n, t;

int main(){
    
    cin >> t;
    while( t -- ){
        
        cin >> n;
    
        for(int i = 0; i < n; i++) cin >> a[i];
        int res = 0;
        for(int i = 0; i < n; i++)
        {
            
            for(int j = 0; j < n; j ++){
                f[j] = 1;           //初始化
                for(int k = 0; k < j; k++)
                    if(a[j] > a[k]) f[j] = max(f[j], f[k] + 1);
                    
                res = max(res, f[j]);
            }
            
            for(int j = n - 1; j >= 0 ; j --){
                f[j] = 1;           //初始化
                for(int k = n - 1; k > j; k--)
                    if(a[j] > a[k]) f[j] = max(f[j], f[k] + 1);
                    
                res = max(res, f[j]);
            }
        }
        cout << res << endl;
    }
    return 0;
}

和怪盗基德类似，对于一个连续的序列，我们从中任取一个作为顶端，起点到顶端取连续上升子序列的最大值，顶端到终点取连续下降子序列的最大长度，相加就是我们想要的值。


代码实现

#include<iostream>
#include<algorithm>

using namespace std;
const int N = 1010;
int f[N], g[N];
int n;
int a[N];

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

计算最少要几名同学出列相当于计算最多可以留下多少个同学，和登山基本上一样，只不过输出结果不一样。
代码：

#include<iostream>
#include<algorithm>

using namespace std;
const int N = 1010;
int f[N], g[N];
int n;
int a[N];

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

对于自变量，是单调上升的子序列，如果自变量对应因变量也是单调上升的，那么说明这种建造桥的方式也是合法的。否则是不合法的
代码

#include<iostream>
#include<algorithm>

using namespace std;
typedef pair<int, int > PII;
const int N = 5010;

PII q[N];
int f[N];
int n;

int main(){
    cin >> n;
    for(int i = 0; i < n; i ++){
        cin >> q[i].first >> q[i].second;
    }
    sort(q, q + n);
    for(int i = 0; i <= n - 1; i++){
        f[i] = 1;
        for(int j = 0; j < i; j++){
            if(q[i].second > q[j].second) f[i] = max(f[i], f[j] + 1);
        }
    }
    int res = 0;
    for(int i = 0; i < n; i++ ) res = max(res, f[i]);
    cout << res << endl;
    return 0;
}

分析过程和之前的一致，只不过所求的属性从最大值变为最大的和。

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 1010;
int f[N], a[N];
int n;

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

总结一下之前的题目的，他们的拓扑过程如下。

线的颜色代表题目转换的难度，绿色代表简单，橙色代表中等，红色代表困难