BZOJ2090: [Poi2010]Monotonicity 2【线段树优化DP】

BZOJ2090: [Poi2010]Monotonicity 2【线段树优化DP】

Description

给出N个正整数a[1..N]，再给出K个关系符号（>、<或=）s[1..k]。
选出一个长度为L的子序列（不要求连续），要求这个子序列的第i项和第i+1项的的大小关系为s[(i-1)mod K+1]。
求出L的最大值。

Input

第一行两个正整数，分别表示N和K (N, K <= 500,000)。
第二行给出N个正整数，第i个正整数表示a[i] (a[i] <= 10^6)。
第三行给出K个空格隔开关系符号（>、<或=），第i个表示s[i]。

Output

一个正整数，表示L的最大值。

Sample Input

7 3
2 4 3 1 3 5 3
< > =

Sample Output

6

HINT

选出的子序列为2 4 3 3 5 3，相邻大小关系分别是< > = < >。

---

思路

暴力的思想是考虑DP

(dp_{i,j})表示以i这一位结束长度为j是否可行

但是发现状态非常冗杂，考虑怎么对状态进行压缩

发现当前的dp状态对后面的影响只有当前数的大小和当前串的长度

又因为我们需要最大化当前串的长度所以可以考虑把当前串的长度进行转化

发现转移的时候需要快速进行一个在值域上进行前缀/后缀/单点查寻的操作

所以可以用线段树维护结尾每个数的大小所能达到的最大dp值，因为还有符号限制，所以就可以用三个线段树维护

然后尝试证明当前dp值在一种符号达到最大的时候一定最优

因为我们的DP只需要考虑当前状态的最佳决策，所以我们不考虑当前状态之后会发生什么

那么接下来就需要证明

• 当i从一个决策点j进行转移的时候，当且仅当j取到最优值
• 也就是说如果j这个点在答案序列中出现，位置只可能是(dp_j)

那么我们假设i是第一个i，有j<i满足(dp_{j}=x)

而j出现在答案中一个不是x的位置y（y<x)，而此时(dp_{i})能更大

首先a[j]与a[i]一定不满足位置x的大小关系，且能满足位置y的大小关系，所以x和y符号一定不相同

而(a_{i}=a_{j})时一定能取到最大值，因为所有j可以转移的位置i都可以转移，i可以顶替j的位置

所以这个时候(a_i!=a_j)

由此可以推出位置y的符号不是等于号

因为(dp_j=x)，且i是第一个i满足由非j的地方转移过来，所以一定存在k<j，(dp_k=y)

那么我们一定有(a_k)与(a_i)不满足位置y的符号，否则i可以由k转移而j在位置y就没有意义了

假设x位置是小于号，那么y位置一定是大于号，且一定有(a_k<a_i)

因为(dp_j=x)，那么一定存在l满足k<l<j，(a_l<a_k<a_i)且(dp_l)的位置是小于号，所以(dp_i)一定可以由(dp_l)转移并且比从位置y转移更优

x上的符号是其他的时候证明类似

---

//Author: dream_maker
#include<bits/stdc++.h>
using namespace std;
//----------------------------------------------
//typename
typedef long long ll;
//convenient for
#define fu(a, b, c) for (int a = b; a <= c; ++a)
#define fd(a, b, c) for (int a = b; a >= c; --a)
#define fv(a, b) for (int a = 0; a < (signed)b.size(); ++a)
//inf of different typename
const int INF_of_int = 1e9;
const ll INF_of_ll = 1e18;
//fast read and write
template <typename T>
void Read(T &x) {
  bool w = 1;x = 0;
  char c = getchar();
  while (!isdigit(c) && c != '-') c = getchar();
  if (c == '-') w = 0, c = getchar();
  while (isdigit(c)) {
    x = (x<<1) + (x<<3) + c -'0';
    c = getchar();
  }
  if (!w) x = -x;
}
template <typename T>
void Write(T x) {
  if (x < 0) {
    putchar('-');
    x = -x; 
  }
  if (x > 9) Write(x / 10);
  putchar(x % 10 + '0');
}
//----------------------------------------------
const int N = 1e6 + 10;
#define LD (t << 1)
#define RD (t << 1 | 1)
struct Segment_Tree {
  int maxv[N << 2];
  void modify(int t, int l, int r, int pos, int vl) {
    maxv[t] = max(maxv[t], vl);
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (pos <= mid) modify(LD, l, mid, pos, vl);
    else modify(RD, mid + 1, r, pos, vl);
  }
  int query(int t, int l, int r, int ql, int qr) {
    if (ql > qr) return 0;
    if (ql <= l && r <= qr) return maxv[t];
    int mid = (l + r) >> 1;
    if (qr <= mid) return query(LD, l, mid, ql, qr);
    else if (ql > mid) return query(RD, mid + 1, r, ql, qr);
    return max(query(LD, l, mid, ql, mid), query(RD, mid + 1, r, mid + 1, qr));
  }
} segment_tree1, segment_tree2, segment_tree3;
int n, k, a[N], dp[N], s[N];
int len = 0, ans = 0;
char c[3];
int main() {
  Read(n); Read(k);
  fu(i, 1, n) {
    Read(a[i]);
    len = max(len, a[i]);
  }
  fu(i, 1, k) {
    scanf("%s", c);
    if (c[0] == '=') s[i] = 1;
    if (c[0] == '>') s[i] = 2;
    if (c[0] == '<') s[i] = 3;
  }
  fu(i, 1, n) {
    dp[i] = max(dp[i], segment_tree1.query(1, 1, len, a[i], a[i]) + 1);
    dp[i] = max(dp[i], segment_tree2.query(1, 1, len, a[i] + 1, len) + 1);
    dp[i] = max(dp[i], segment_tree3.query(1, 1, len, 1, a[i] - 1) + 1);
    int ind = (dp[i] - 1) % k + 1;
    if (s[ind] == 1) segment_tree1.modify(1, 1, len, a[i], dp[i]);
    if (s[ind] == 2) segment_tree2.modify(1, 1, len, a[i], dp[i]);
    if (s[ind] == 3) segment_tree3.modify(1, 1, len, a[i], dp[i]);
    ans = max(ans, dp[i]);
  }
  Write(ans);
  return 0;
}