codeforces934C. A Twisty Movement (dp)

半天没人写博客，索性自己写吧，有人用的线段树写的，不过我一看题目第一感觉还是dp，毕竟是要求子序列嘛。。

题意是给你一串1和2的序列，要求你从中选择一段区间，颠倒区间内的元素，使得非降序子序列长度最大，输出长度。

一看这题思路其实很好想，前几天随便看nowcoder题库的看过类似题目，所以马上就知道肯定是求出两个数组，一个表示非降序一个表示非升序，最后两者相加即可。

不过这题的样例误导了很多人，这就是很基础的dp题，没必要想多了考虑连续子序列，毕竟那样没什么意义，貌似这样出题还是更简单写吧，orz。

我们借鉴LIS的写法，lis是很基础的dp，不明白的过一遍就会了。但是这题要求不一定连续，所以我们还要开两个数组，pre【i】表示index<=i 时我们可以得到的非降序子序列最大长度，nxt【i】表示index>=i 时我们可以得到的非升序子序列最大长度，那么最后我们开一个循环表示颠倒区间的起点，没必要考虑终点why？ 我们不是说了吗这是不连续的，所以我们只要pre【i】+nxt【i+1】就可以了，还是因为非连续的原因，仔细想想是不是？

总结：很好的题，算是情理之中的题吧，说难不难说简单不简单，第一次遇到的可以当做模板使用啊

我先附上AC代码：

#include<bits/stdc++.h>
using namespace std;
#define LL long long

const int maxn=2005;
int n,ans;
int pre[maxn],nxt[maxn],dp[maxn],a[maxn];

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;++i)
        scanf("%d",&a[i]);
	for(int i=1;i<=n;++i)
    {
		dp[i]=1;
		for(int j=1;j<i;++j)
			if(a[j]<=a[i]&&dp[j]+1>dp[i])
                dp[i]=dp[j]+1;
		pre[i]=max(dp[i],pre[i-1]);
	}
//    for(int i=1;i<=n;i++)
//        cout<<pre[i]<<" ";
//    cout<<endl;
//    for(int i=1;i<=n;i++)
//        cout<<dp[i]<<" ";
//    cout<<endl;

	for(int i=n;i>=1;--i)
	{
		dp[i]=1;
		for(int j=n;j>i;--j)
			if(a[j]>=a[i]&&dp[j]+1>dp[i])
                dp[i]=dp[j]+1;
		nxt[i]=max(dp[i],nxt[i+1]);
	}
	
//	for(int i=1;i<=n;i++)
//        cout<<nxt[i]<<" ";
//    cout<<endl;
//    for(int i=1;i<=n;i++)
//        cout<<dp[i]<<" ";
//    cout<<endl;

	for(int i=1;i<=n;++i)
        ans=max(ans,pre[i]+nxt[i+1]);
	printf("%d",ans);
	return 0;
}

之前我不是说过看过类似的题目吗？

顺便提供给读者，比这题难度稍微高一丢丢而已

题目：牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。（nowcoder 牛牛的数列）

代码不是自己写的，随便看看吧

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int main()
{
    int n;
    while (cin >> n)
    {
        vector<int> v(n, 0);
        for (int i = 0; i < n; ++i)
            cin >> v[i];
        if (n == 0 || n == 1)
        {
            cout << n << endl;
            continue;
        }
        vector<int> dp1( n, 0 ); //dp1[i]是以v[i]开始的最长上升子序列
        vector<int> dp2( n, 0 ); //dp2[i]是以v[i]结尾的最长上升子序列
 
        dp1[n - 1] = 1;
        for (int i = n - 2; i >= 0; --i)
        {
            if (v[i] < v[i + 1])
                dp1[i] = dp1[i + 1] + 1;
            else
                dp1[i] = 1;
        }
 
        dp2[0] = 1;
        for (int i = 1; i < n - 1; ++i)
        {
            if (v[i] > v[i - 1])
                dp2[i] = dp2[i - 1] + 1;
            else
                dp2[i] = 1;
        }
 
        int ret = 1;
        int m = 1;
        for (int i = 0; i < n - 1; ++i)
        {
            if (i == 0)
                m = dp1[i + 1] + 1;
            else if (i == n - 1)
                m = dp2[i - 1] + 1;
            else if (v[i - 1] + 1 < v[i + 1])
                m = dp1[i + 1] + dp2[i - 1] + 1;
            else
                m = max(dp1[i + 1], dp2[i - 1]) + 1;
            if (m > ret)
                ret = m;
        }
        cout << ret << endl;
    }
}