[USACO17JAN]Subsequence Reversal

嘟嘟嘟

 

这题刚开始是什么思路也没有，关键是不知道怎么解决序列反转的问题。

然后我就想到如果暴力反转一个序列的话，实际上就是不断交换数组中的两个数a_i和a_j，同时要满足交换的数不能交叉。

然后又看了一眼（岂止一眼）题解，因为a_i <= 50，所以令dp[i][j][L][R]表示区间[i, j]，min(a_k) >= L, max(a_k) <= R时，反转一次的最长不下降子序列。

显然是一个区间dp，那么[i, j]可以从[i + 1, j]，[i, j - 1]或是[i + 1, j - 1]转移过来，所以L,R也只可能从a_i+1,a_j-1转移过来。然后还要考虑交换或者不交换的情况。代码就是dp式了，这里就不写了

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 55;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) {last = ch; ch = getchar();}
  while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n, a[maxn];
int dp[maxn][maxn][maxn][maxn];

int main()
{
  n = read();
  for(int i = 1; i <= n; ++i) a[i] = read(), dp[i][i][a[i]][a[i]] = 1;
  for(int len = 2; len <= n; ++len)
    for(int i = 1; i + len - 1 <= n; ++i)
      {
    int j = i + len - 1;
    for(int l = 1; l <= 50; ++l)
      for(int L = 1; L + l - 1 <= 50; ++L)
        {
          int R = L + l - 1;
          dp[i][j][L][R] = max(dp[i][j][L][R], max(dp[i + 1][j][L][R], dp[i][j - 1][L][R]));
          dp[i][j][L][R] = max(dp[i][j][L][R], max(dp[i][j][L + 1][R], dp[i][j][L][R - 1]));
          dp[i][j][min(L, a[i])][R] = max(dp[i][j][min(L, a[i])][R], dp[i + 1][j][L][R] + (a[i] <= L));
          dp[i][j][L][max(R, a[j])] = max(dp[i][j][L][max(R, a[j])], dp[i][j - 1][L][R] + (a[j] >= R));
          dp[i][j][min(L, a[j])][R] = max(dp[i][j][min(L, a[j])][R], dp[i + 1][j - 1][L][R] + (a[j] <= L));  //一下三行是ai和aj交换
          dp[i][j][L][max(R, a[i])] = max(dp[i][j][L][max(R, a[i])], dp[i + 1][j - 1][L][R] + (a[i] >= R));
          dp[i][j][min(L, a[j])][max(R, a[i])] = max(dp[i][j][min(L, a[j])][max(R, a[i])], dp[i + 1][j - 1][L][R] + (a[i] >= R) + (a[j] <= L));
        }
      }
  write(dp[1][n][1][50]), enter;
  return 0;
}