最长递增子序列

给定数组arr，设长度为n，输出arr的最长递增子序列。（如果有多个答案，请输出其中字典序最小的）

输入描述:

输出两行，第一行包括一个正整数n（n<=100000），代表数组长度。第二行包括n个整数，代表数组arr (1≤arri≤1e9)。

输出描述:

输出一行。代表你求出的最长的递增子序列。

分析：参考我之前写的两篇关于对于动态规划的分析，这一题主要的思想还是用一个dp数组来记录以arr[i]结尾的最长不下降子序列长度以及其前序元素

由此，就能写出状态转移方程 dp[i]=max{1,dp[j]+1} (j=1,2,...,i-1&&arr[j]<arr[i])

核心思想明确后，再根据实际问题来处理输出，处理字典序就是注意更新dp数组的一些其他情况。

参考题解：

#include<iostream>
#include<vector>
using namespace std;
struct node{
    int count=1;
    int pre=-1;
};
int main(){
    int n,max=0,tag=-1;
    cin>>n;
    vector<int> arr(n);
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    vector<node> dp(n);
    for(int i=1;i<n;i++){
        for(int j=0;j<i;j++){
            if(arr[i]>arr[j]){
                if(dp[j].count>=dp[i].count){
                    dp[i].count=dp[j].count+1;
                    dp[i].pre=j;
                }else if(dp[j].count+1==dp[i].count&&arr[j]<arr[dp[i].pre]){
                    dp[i].pre=j;
                }
            }
        }
    }
    for(int i=0;i<n;i++){
        if(dp[i].count>max){
            max=dp[i].count;
            tag=i;
        }else if(dp[i].count==max&&arr[i]<arr[tag]){
            tag=i;
        }
    }
    vector<int> ans;
    while(dp[tag].pre!=-1){
        ans.push_back(arr[tag]);
        tag=dp[tag].pre;
    }
    ans.push_back(arr[tag]);
    for(int i=ans.size()-1;i>=0;i--){
        if(i==0){
            cout<<ans[0];
            break;
        }
        cout<<ans[i]<<" ";
    }
    return 0;
}