HDU 6357.Hills And Valleys-字符串非严格递增子序列(LIS最长非下降子序列)+动态规划(区间翻转l，r找最长非递减子序列)，好题哇 (2018 Multi-University Training Contest 5 1008)

6357.

Hills And Valleys

自己感觉这是个好题，应该是经典题目，所以半路选手补了这道字符串的动态规划题目。

题意就是给你一个串，翻转任意区间一次，求最长的非下降子序列。

一看题面写的0≤Ai≤9 (i=1,2,⋯,n).就知道肯定有点东西，只要这么写，肯定就是有某个神奇的操作可以解决这道题目。

比赛的时候脑壳都要炸了也没想出来，补题的时候懂了，我可以定义一个b串为0123456789，这肯定是递增的，所以我翻转b的某个区间，然后去和a匹配，因为我把b再翻转回来，还是递增的。

当然了，因为是非严格的递增子序列，有相等的情况，所以相等的时候判断一下，直接+1就可以了。然后枚举一下b的翻转区间就可以了。因为还要输出翻转的区间，所以在dp的时候，用个数组分别保存一下l，r端点就可以了。其他的没什么。

感觉这种思路还是很值得思考的，不处理a，通过其他的操作间接处理a，以后写题要多想想，也写过类似思路的，通过其他的操作间接得到答案，但是一打比赛就没脑子，mdzz，为什么我这么菜༼༎ຶᴗ༎ຶ༽

参考了其他人的题解写出来的。

首先官方题解:

然后别人的博客:HDU6357——Hills And Valleys

代码:

//1008-6357-非严格递增子序列(最长非下降子序列)-字符串+dp-区间翻转，r找最长非递减子序列，好题哇
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
using namespace std;
typedef long long ll;

const double PI=acos(-1.0);
const double eps=1e-6;
const ll mod=1e9+7;
const int inf=0x3f3f3f3f;
const int maxn=1e5+10;
const int maxm=20+10;
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

int n,a[maxn],dp[maxn][maxm],b[maxm];
int ans,L,R,l,r,h;
int al[maxn][maxm],ar[maxn][maxm];

int solve()
{
    for(int i=0;i<=h;i++)
        dp[0][i]=0;//初始化
    for(int i=1;i<=n;i++){//a和b匹配
        for(int j=1;j<=h;j++){
            dp[i][j]=dp[i-1][j];
            al[i][j]=al[i-1][j];//记录左端点
            ar[i][j]=ar[i-1][j];//记录右端点
            if(a[i]==b[j]){//如果有相等的情况，+1
                dp[i][j]=dp[i-1][j]+1;
                if(l==j&&!al[i][j])//如果当前的j就是b开始翻转的左端点,更新记录
                    al[i][j]=i;
                if(r==j)//右端点
                    ar[i][j]=i;
            }
            if(dp[i][j-1]>dp[i][j]){//更新答案
                dp[i][j]=dp[i][j-1];
                al[i][j]=al[i][j-1];
                ar[i][j]=ar[i][j-1];
            }
        }
    }
    return dp[n][h];
}

char s[maxn];

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%s",&n,s+1);
        for(int i=1;i<=n;i++)
            a[i]=s[i]-'0';
        h=0;
        for(int i=0;i<=9;i++)
            b[++h]=i;
        L=R=l=r=1;
        ans=solve();
        for(int i=0;i<=9;i++){
            for(int j=i+1;j<=9;j++){
                h=0;
                for(int k=0;k<=i;k++)
                    b[++h]=k;//翻转区间的左部分不变
                l=h+1;
                for(int k=j;k>=i;k--)//要翻转的区间把数字翻转
                    b[++h]=k;
                r=h;
                for(int k=j;k<=9;k++)//反转区间的右部分不变
                    b[++h]=k;
                int tmp=solve();
                if(ans<tmp&&al[n][h]&&ar[n][h]){//更新结果
                    ans=tmp;
                    L=al[n][h];
                    R=ar[n][h];
                }
            }
        }
        printf("%d %d %d
",ans,L,R);
    }
}

溜了溜了，滚去补数据结构了。