AtCoder Beginner Contest 234 G - Divide a Sequence

传送门

题目描述#

把一个长度为 $N$ 的数组 $A$, 分为几个连续的子序列 $B_1, B_2, ... , B_k$，有 $2^{N-1}$ 种划分方式

先给出数组 $A$ 求出所有划分方式的价值之和，并对 $998244353$ 取模.

对于一种划分方式 $B_1, B_2, ... , B_k$ 的价值为 ${\textstyle \prod_{i=1}^{k}} (\max(B_i) - \min(B_i))$

对于一个子序列$B_i = (B_{i,1}, B_{i,1}, ..., B_{i,j} )$ ，其中最大的元素为 $\max(B_i)$，最小的元素为 $\min(B_i)$

思路#

首先我们可以想到一个 $n^2$ 的 $DP$
定义 $f_i$ 为前 $i$ 个数字的所有划分方式的价值之和
那么可以得到转移方程 $f_i = \sum_{j=1}^{i-1} f_j \times (\max(a_{j+1},.., a_{i}) - \min(a_{j+1},.., a_{i}))$
(不包含 $f_{i-1}$ 的原因是 单个数字的价值为 $0$)
通过倒序遍历可以维护出 $\max, \min$ 因此复杂度为 $O(n^2)$

这么写肯定是会 $TLE$ 的

因此我们考虑如何去优化

我们可以把 $\max$ 和 $\min$ 的贡献单独去考虑 (这也是常用的一个套路)

首先分析 $\max$#

转移方程 $f_i = \sum_{j=1}^{i-1} f_j \times (\max(a_{j+1},.., a_{i}) - \min(a_{j+1},.., a_{i}))$
可以转换为 $f_i = \sum_{j=1}^{i-1} f_j \times \max(a_{j+1},.., a_{i}) - \sum_{j=1}^{i-1} f_j \times \min(a_{j+1},.., a_{i})$

我们可以用 $m_i$ 代表当前的 $\max$ 的价值和
那么 $m_i$ 和 $m_{i-1}$ 是否存在什么联系呢？ 答案是存在的

我们考虑的是最大值对答案的贡献
对于 $f_i$ 来说，产生贡献的最大值一定是单调上升的一些数字，因为我们 $f_i$ 进行转移的时候是根据最后一段子序列进行分类的
$f_i$ 是由 $f_{i-2}, f_{i-3}, ..., f_{1}, f_{0}$ 转移过来的，我们后缀最大值的贡献一定是在一个连续的区间，并且是单调递增的
那么我们就可以利用一个单调栈，每次弹出栈顶的时候减去栈顶的所有贡献，然后在最后加上当前位置的贡献即可

最小值同理

CODE

/********************
Author:  Nanfeng1997
Contest: AtCoder - AtCoder Beginner Contest 234
URL:     https://atcoder.jp/contests/abc234/tasks/abc234_g
When:    2022-03-16 10:28:26

Memory:  1024MB
Time:    2000ms
********************/
#include  <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MOD = 998244353;

inline int mod(int x) {return x >= MOD ? x - MOD : x;}

inline int ksm(int a, int b) {
  int ret = 1; a = mod(a);
  for(; b; b >>= 1, a = 1LL * a * a % MOD) if(b & 1) ret = 1LL * ret * a % MOD;
  return ret;
}

template<int MOD> 
struct modint {
  int x;
  modint() {x = 0; }
  modint(int y) {x = y;}
  inline modint inv() const { return modint{ksm(x, MOD - 2)}; }
  explicit inline operator int() { return x; }
  friend inline modint operator + (const modint &a, const modint& b) { return modint(mod(a.x + b.x)); }
  friend inline modint operator - (const modint &a, const modint& b) { return modint(mod(a.x - b.x + MOD)); }
  friend inline modint operator * (const modint &a, const modint& b) { return modint(1ll * a.x * b.x % MOD); }
  friend inline modint operator - (const modint &a) { return modint(mod(MOD - a.x)); }
  friend inline modint& operator += (modint &a, const modint& b) { return a = a + b; }
  friend inline modint& operator -= (modint &a, const modint& b) { return a = a - b; }
  friend inline modint& operator *= (modint &a, const modint& b) { return a = a * b; }
  inline int operator == (const modint &b) { return x == b.x; }
  inline int operator != (const modint &b) { return x != b.x; }
  inline int operator < (const modint &a) { return x < a.x; }
  inline int operator <= (const modint &a) { return x <= a.x; }
  inline int operator > (const modint &a) { return x > a.x; }
  inline int operator >= (const modint &a) { return x >= a.x; }
};

typedef modint<MOD> mint;

inline mint ksm(mint a, int b) {
  mint ret = 1; 
  for(; b; b >>= 1, a = a * a ) if(b & 1) ret = ret * a ;
  return ret;
}

const int N = 3e5 + 10;

int n;
int a[N], s1[N], s2[N];
mint dp[N], tr[N];

void add(int a, mint k) {
  while(a <= n) tr[a] += k, a += a & -a;
}

mint query(int x) {
  mint ret = 0; if(x >= 0) ret += 1; //树状数组的边界是1, 因此我们手动加上0处的贡献
  while(x > 0) ret += tr[x], x -= x & -x;
  return ret;
}

mint ask(int l, int r) {return query(r) - query(l - 1); }

void solve() {
  scanf("%d", &n);
  for(int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
  int t1 = 0, t2 = 0;
  mint mx = 0, mi = 0; 

  //dp[0] = 1, 因为我们进行转移的时候是乘法，乘法的幺元是 1
  //mx 是最大值的贡献 
  //mi 是最小值的贡献
  
  for(int i = 1; i <= n; i ++ ) {

    while(t1 && a[s1[t1]] <= a[i]) {
      int t = s1[t1 --];
      mint ret = ask(s1[t1], t - 1);
      mx = mx - ret * a[t];
    }

    mx = mx + ask(s1[t1], i) * a[i];
    s1[++ t1] = i;
    
    while(t2 && a[s2[t2]] >= a[i]) {
      int t = s2[t2 --];
      mint ret = ask(s2[t2], t - 1);
      mi = mi - ret * a[t];
    }

    mi = mi + ask(s2[t2], i) * a[i];
    s2[++ t2] = i;

    dp[i] = mx - mi;
    add(i, dp[i]);
  }
  printf("%d", (int)dp[n]);

}

int main() {
  // ios::sync_with_stdio(false);
  // cin.tie(nullptr);
  int T = 1; //cin >> T;
  while(T --) solve();

  return 0;
}