<think>首先，用户的问题是关于计算数组中满足特定条件的子序列数量。条件是：子序列中有一个最大值，最大值左边严格升序，最大值右边严格降序。结果需要对998244353取模。
我需要理解这个条件。用户称之为“丸山定义”，但我不知道这个术语；可能是一个特定名称或用户自定义。无论如何，我应该基于描述来理解。
关键点是：
- 子序列必须有一个最大值（只有一个最大值）。
- 最大值左边的元素必须严格升序（从左到右递增）。
- 最大值右边的元素必须严格降序（从左到右递减）。
子序列是数组中的元素序列，不一定连续，但顺序必须保持原数组的顺序。
例如，对于数组 [1,3,2]，子序列 [1,3] 满足：最大值是3，左边[1]升序，右边无元素。
另一个例子：[1,3,2] 本身：最大值是3，左边[1]升序，右边[2]降序。
但 [1,2,3] 不满足，因为最大值3在末尾，左边[1,2]升序，但右边无元素，所以满足？用户说“有且仅有一个最大值”，所以如果最大值在末尾，左边升序，右边无元素，应该也满足，因为右边是空序列，可以视为降序（空序列通常被视为满足条件）。
类似地，如果最大值在开头，左边无元素，右边降序。
所以，子序列可以以最大值开头或结尾。
现在，我需要计算所有这样的子序列的数量。
数组大小未指定，但既然是编程问题，我需要一个高效的算法，因为数组可能很大。
结果取模998244353，这是一个大质数，常用于编程竞赛。
我应该设计一个动态规划（DP）解决方案。
让我定义DP状态。
一个常见的方式是考虑每个位置作为最大值的情况。
但子序列的最大值可能不是数组的最大值；它是子序列中的最大值。
所以，我需要对于每个元素，考虑它作为最大值时的贡献。
定义：
让数组为 arr，长度为 n。
我需要对于每个位置 i（0-indexed），计算以 arr[i] 为最大值的满足条件的子序列数量。
然后，总数量是所有 i 的贡献之和。
现在，对于固定的 i，以 arr[i] 为最大值。
在子序列中，arr[i] 是最大值，所以所有元素 ≤ arr[i]。
但条件是关于顺序：左边部分必须严格升序，右边部分严格降序。
左边部分：在子序列中，最大值左边的元素必须严格升序，并且都小于 arr[i]（因为 arr[i] 是最大值）。
类似地，右边部分必须严格降序，并且都小于 arr[i]。
由于子序列的顺序必须保持原数组顺序，所以左边部分必须在 i 的左边（索引小于 i），右边部分在 i 右边（索引大于 i）。
在子序列中，元素顺序保持原序，所以最大值左边的元素在数组中都位于 i 左边，右边元素都位于 i 右边。
是的。
所以，对于固定 i，以 arr[i] 为最大值，子序列由三部分组成：
- 左部分：索引在 [0, i-1] 的子序列，严格升序，以某个元素结尾，但等等，不一定以 i-1 结尾；它可以是任意子序列，但必须严格升序，并且所有元素 < arr[i]，因为 arr[i] 是最大值。
类似地，右部分：索引在 [i+1, n-1] 的子序列，严格降序，所有元素 < arr[i]。
而且，左部分和右部分可以为空。
空序列是允许的。
现在，左部分：我需要所有严格升序子序列，其中元素来自 arr[0..i-1]，元素值 < arr[i]。
但子序列必须严格升序，所以顺序是固定的：从左到右递增。
类似地，右部分：严格降序子序列，元素来自 arr[i+1..n-1]，元素值 < arr[i]，顺序从右到左递减？等等。
定义清楚。
对于右部分：在子序列中，它是最大值右边的元素，顺序必须严格降序，意思是当从左到右读时，是递减的。
例如，在子序列中，位置：max 在中间，左边升序，右边降序。
所以，对于右部分，元素在数组索引 j > i，在子序列中，它们出现在 max 之后，顺序是 arr[j1], arr[j2], ... 其中 j1 < j2 < ...（因为顺序保持），并且 arr[j1] > arr[j2] > ... 严格降序。
由于索引 j > i 且 j 递增，但值必须严格递减。
类似地，左部分：索引 k < i，k 递减？等等。
在子序列中，左部分在 max 之前，所以元素顺序是 ... , arr[k2], arr[k1], max 其中 k1 < k2 < ... 索引，但值 arr[k1] < arr[k2] < ... 严格升序？等等。
假设子序列索引序列：p1, p2, ..., pm, i, q1, q2, ..., qr
其中 p 是左部分索引，q 是右部分索引。
p1 < p2 < ... < pm < i < q1 < q2 < ... < qr
值：arr[p1] < arr[p2] < ... < arr[pm] < arr[i] 因为严格升序到 max，且 max 是最大值。
然后 arr[i] > arr[q1] > arr[q2] > ... > arr[qr] 严格降序。
所有值 < arr[i]。
对于固定 i，左部分的数量是所有严格升序子序列的数量，元素来自 {arr[k] for k=0 to i-1}，但只考虑值 < arr[i]，并且子序列必须严格升序，索引递增，值递增。
由于索引递增，值也必须递增，所以是严格递增子序列。
类似地，对于右部分，元素来自 {arr[k] for k=i+1 to n-1}, 值 < arr[i], 子序列索引递增，但值必须严格递减。
所以，对于左部分，我需要计算在 arr[0..i-1] 中，值 < arr[i] 的严格递增子序列的数量。
但子序列包括空序列。
类似地，对于右部分，在 arr[i+1..n-1] 中，值 < arr[i] 的严格递减子序列的数量。
严格递减子序列，索引递增，值递减。
现在，对于左部分，设 L[i] 为在 arr[0..i-1] 中，值 < arr[i] 的严格递增子序列的数量。
类似地，对于右部分，R[i] 为在 arr[i+1..n-1] 中，值 < arr[i] 的严格递减子序列的数量。
然后，对于每个 i，以 arr[i] 为最大值的子序列数量是 L[i] * R[i] * 1，因为左部分任意选择，右部分任意选择，max 固定。
但左部分的数量包括空序列，所以当左部分空时，是1种方式（不选任何元素），类似地右部分。
所以是的。
然后总数量是 sum_{i=0}^{n-1} L[i] * R[i]
但 L[i] 和 R[i] 依赖于 i。
现在，我需要计算 L[i] 和 R[i] 对于每个 i。
首先，L[i]：在 arr[0..i-1] 中，值 < arr[i] 的严格递增子序列的数量。
这包括空序列。
类似地，R[i]：在 arr[i+1..n-1] 中，值 < arr[i] 的严格递减子序列的数量。
现在，问题是如何高效计算这些。
由于数组可能大，我需要 O(n^2) 或更好的方法。
计算所有位置的严格递增子序列数量。
一个标准方法是使用 DP 和 Fenwick 树或线段树来优化。
类似地用于递减。
首先，处理值：值可能很大，所以我可能需要坐标压缩。
但让我们先写出方程。
对于每个 i，L[i] = 1 + 所有以某个 k 结尾的严格递增子序列的数量，其中 k < i，arr[k] < arr[i]，但等等。
L[i] 是子序列的数量，不一定以 i-1 结尾。
它是所有严格递增子序列的数量，这些子序列由索引小于 i 且值小于 arr[i] 的元素组成。
所以，对于索引范围 [0, i-1]，值小于 arr[i]。
但值约束是 arr[k] < arr[i]，其中 k < i。
现在，定义 f(j) 为在 arr[0..j] 中，以 arr[j] 结尾的严格递增子序列的数量。
但 L[i] 不是以 i 结尾的；它是所有子序列，包括不以特定位置结尾的。
所以，更好的方式：设 A 为 arr[0..i-1] 的子数组。
那么，L[i] 是 A 中所有严格递增子序列的数量，包括空序列。
这可以通过对所有位置 j < i，计算以 j 结尾的严格递增子序列的数量之和来得到，但只考虑 arr[j] < arr[i]，并且我们需要值小于 arr[i]。
由于我们只考虑值小于 arr[i] 的元素，所以令 S = { k | 0 <= k < i and arr[k] < arr[i] }
那么，L[i] 是 S 中所有严格递增子序列的数量，包括空序列。
现在，S 中的元素是索引，但值 arr[k] 用于排序。
要计算一个集合中严格递增子序列的数量，我们可以使用 DP。
定义 dp_inc[j] 为在索引 j 处结尾的严格递增子序列的数量，其中 j 在 [0, i-1] 中，但只考虑值小于 arr[i] 的情况。
但 L[i] 是所有这样的子序列的总和，包括空序列。
所以，对于索引范围 [0, i-1]，只考虑值小于 arr[i] 的元素，令这些位置为 k1, k2, ..., km，其中 k1 < k2 < ... < km 且 arr[k1] < arr[k2] < ... < arr[km]？不一定，索引顺序是固定的，但值可能不排序。
位置：对于所有满足 0 <= k < i 且 arr[k] < arr[i] 的 k。
现在，严格递增子序列：我们需要选择索引的子序列 p1 < p2 < ... < pt，其中 p 属于上述集合，并且 arr[p1] < arr[p2] < ... < arr[pt]。
这样的子序列数量。
这可以通过动态规划计算：对于每个位置，以该位置结尾的子序列数量。
但只考虑值小于 arr[i] 的位置。
所以，对于固定的 i，我可以在 O(i) 时间内计算 L[i]，但那样对于所有 i 的总代价是 O(n^2)，对于 n 很大时可能不够高效。
n 可能达到 10^5，所以 O(n^2) 太慢。
我需要更高效的方法。
类似地，对于 R[i]。
所以，我应该预处理一些东西。
首先，忽略值约束，计算所有位置左侧的严格递增子序列总数。
但值约束是特定于每个 i 的。
一个更好的方法是：考虑所有元素，并计算以每个位置结尾的严格递增子序列的数量。
定义 dp_inc[i] 为以索引 i 结尾的严格递增子序列的数量。
那么，dp_inc[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
初始：对于每个 i，dp_inc[i] 至少为 1（只包含单个元素）。
然后，所有递增子序列的总数（包括空序列）是 1 + 所有 dp_inc[i] 的总和，但等等，不对。
令 S_inc 为所有严格递增子序列的数量，包括空序列。
那么 S_inc = 1 + 所有 i 的 dp_inc[i] 的总和，因为每个非空子序列在某个 i 结束。
类似地，对于固定范围，但值有约束。
对于 L[i]，我需要的是在索引范围 [0, i-1] 内，值小于 arr[i] 的元素组成的严格递增子序列的数量。
这类似于在查询值 arr[i] 时，前缀 [0, i-1] 中值小于 arr[i] 的递增子序列的数量。
但我需要对于每个 i 都计算这个。
所以，我可以在遍历 i 时，使用 Fenwick 树或线段树来维护。
让我定义在索引范围 [0, i-1] 中，值小于某个 v 的递增子序列的数量。
但 v 是 arr[i]，它依赖于 i。
标准做法：当我处理到 i 时，我已经处理了 [0, i-1]，并且我可以用树来查询值小于 arr[i] 的 dp_inc[j] 的总和。
但 L[i] 是子序列的数量，而不是以某个位置结尾的数量。
回忆一下：对于一个集合，严格递增子序列的数量（包括空序列）可以通过对所有位置 j 的以 j 结尾的递增子序列数量求和再加 1 得到（空序列）。
设 T 为索引集合，比如所有满足 k < i 且 arr[k] < arr[i] 的 k。
那么，L[i] = 1 + 所有 j 属于 T 的 dp_inc[j] 的总和，其中 dp_inc[j] 是以 j 结尾的递增子序列的数量，但 dp_inc[j] 是全局的，还是只针对该集合的？
dp_inc[j] 是定义在索引 j 上的，但当我们考虑子集时，我们需要在子集中定义。
但在这个例子中，对于索引范围 [0, i-1]，并且只考虑值小于 arr[i] 的元素，所以对于这些 j，dp_inc_local[j] 表示在 [0, i-1] 中，以 j 结尾的严格递增子序列的数量，但仅考虑值小于 arr[i] 的元素，但既然我们已经过滤了，所有值都小于 arr[i]，所以我们可以使用全局的 dp_inc，但只针对这些 j。
定义全局的 dp_inc[i]，表示在所有元素中，以 i 结尾的严格递增子序列的数量，但只考虑索引 <= i，所以是前缀。
通常，dp_inc[i] 是通过所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和来计算的。
但那是针对所有元素的情况，没有值限制。
对于 L[i]，在 [0, i-1] 中，值小于 arr[i] 的递增子序列的数量。
首先，集合 T = {j | 0 <= j < i 且 arr[j] < arr[i]}
那么，以 k 属于 T 结尾的递增子序列的数量是 dp_inc[k]，但 dp_inc[k] 是全局的，并且包括所有更早的元素，这些元素可能值更小，但既然我们只考虑值小于 arr[i] 的元素，并且所有更早的 j 满足 arr[j] < arr[k] <= arr[i]？arr[k] < arr[i]，但更早的元素可能更大，但 dp_inc[k] 只对满足 arr[j] < arr[k] 的 j 求和，所以如果 arr[k] < arr[i]，那么所有在 dp_inc[k] 中的元素值都小于 arr[k] < arr[i]，所以它们都在 T 中，因此没问题。
设 dp_inc[i] 表示在数组 [0..i] 中，以 i 结尾的严格递增子序列的数量，但只考虑索引 <= i。
更准确地说：当我们计算 dp_inc[i] 时，我们考虑所有 j < i 且 arr[j] < arr[i] 的情况。
对于 L[i]，我们需要在 [0, i-1] 中，值小于 arr[i] 的递增子序列数量。
这包括空序列和所有以某个 k 结尾的序列，其中 k 属于 T。
所以，L[i] = 1 + 所有满足 k < i 且 arr[k] < arr[i] 的 dp_inc[k] 的总和
因为每个非空子序列都在某个 k 结束，而 dp_inc[k] 包含了所有以 k 结尾的序列。
而空序列由 1 表示。
类似地，对于右侧部分，但用于递减序列。
首先，对于递增部分。
所以，对于每个 i，L[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
但 dp_inc[j] 是定义在 j 上的，而 j < i。
现在，dp_inc[j] 本身是用于计算全局的以 j 结尾的递增子序列数量的。
但在这个总和中，对于 L[i]，我们需要所有满足 j < i 且 arr[j] < arr[i] 的 j 的 dp_inc[j] 的总和。
类似地，对于右侧部分。
首先，我需要计算 dp_inc 数组。
定义 dp_inc[i] 为以索引 i 结尾的严格递增子序列的数量。
那么对于每个 i，dp_inc[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
其中 1 是只包含 arr[i] 的子序列。
然后，所有递增子序列的总数是 1 + 所有 dp_inc[i] 的总和（i 从 0 到 n-1），包括空序列。
但对于 L[i]，如上所述，L[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
在计算 dp_inc[i] 时，我们恰好需要所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和。
所以，对于每个 i，当我们计算 dp_inc[i] 时，令 S_inc(i) = 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
那么 dp_inc[i] = 1 + S_inc(i)
而 L[i] = 1 + S_inc(i) ？不对。
L[i] 是对于 [0, i-1] 中值小于 arr[i] 的元素，但 S_inc(i) 是用于计算 dp_inc[i] 的总和，其中包含满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j]，但 j 在 [0, i-1] 中，并且 arr[j] < arr[i]，所以 S_inc(i) 是 [0, i-1] 中所有满足 arr[j] < arr[i] 的 dp_inc[j] 的总和。
那么 L[i] = 1 + S_inc(i)
因为 L[i] = 1 + 所有满足条件的 j 的 dp_inc[j] 的总和
而 S_inc(i) 正好是那个总和。
但 S_inc(i) 是在计算 dp_inc[i] 时定义的。
对于 L[i]，当 i 是最大值索引时，我们需要 L[i] 用于子序列，其中最大值在 i，所以对于 L[i]，我们考虑的是 [0, i-1] 中值小于 arr[i] 的元素，所以是的。
在表达式 L[i] = 1 + S_inc(i) 中
S_inc(i) 依赖于 i。
类似地，对于右侧部分，我们需要 R[i]，即在 [i+1, n-1] 中，值小于 arr[i] 的严格递减子序列的数量。
首先，定义递减部分。
定义 dp_dec[i] 为以索引 i 结尾的严格递减子序列的数量。
但递减子序列：索引递增，值递减。
所以，对于以 i 结尾的严格递减子序列，dp_dec[i] = 1 + 所有满足 j > i 且 arr[j] < arr[i] 的 dp_dec[j] 的总和？不对。
如果子序列是严格递减的，并且索引递增，那么对于以 i 结尾的序列，我们需要在 i 之后的元素，但值更小？我们来定义一下。
设我们有一个子序列，索引为 ... , p, q, i，其中 p < q < i，并且 arr[p] > arr[q] > arr[i]，用于递减序列？不对。
对于严格递减子序列，索引递增，值递减，所以序列是 arr[j1] > arr[j2] > ... > arr[jk]，其中 j1 < j2 < ... < jk。
所以，对于以索引 i 结尾的情况，我们需要在 i 之后、值小于 arr[i] 的元素？不对。
如果子序列以 i 结尾，并且索引递增，那么 i 是最后一个索引，所以前面的元素必须在 i 之前，索引更小，但值更大，因为是递减的。
例如，子序列：索引 j < k < i，并且 arr[j] > arr[k] > arr[i]。
所以对于以 i 结尾的严格递减子序列，dp_dec[i] = 1 + 所有满足 j < i 且 arr[j] > arr[i] 的 dp_dec[j] 的总和？但 dp_dec[j] 是以 j 结尾的，所以对于组合，我们需要在 j 和 i 之间的元素。
标准方式：dp_dec[i] 表示以索引 i 结尾的严格递减子序列的数量。
那么，对于每个 i，dp_dec[i] = 1 + 所有满足 j < i 且 arr[j] > arr[i] 的 dp_dec[j] 的总和
因为对于每个 j < i 且 arr[j] > arr[i]，我们可以将 i 附加到所有以 j 结尾的递减子序列之后，并且由于 arr[j] > arr[i]，序列保持递减。
此外，还有只包含 i 的子序列。
所以，是的，dp_dec[i] = 1 + 所有满足 j < i 且 arr[j] > arr[i] 的 dp_dec[j] 的总和
但顺序是索引递增，值递减。
对于 R[i]，我们需要在索引范围 [i+1, n-1] 中，值小于 arr[i] 的严格递减子序列的数量。
所以，对于右侧部分。
令 U = {k | i+1 <= k <= n-1 且 arr[k] < arr[i]}
那么，R[i] 是 U 中所有严格递减子序列的数量，包括空序列。
所以，R[i] = 1 + 所有满足 k 属于 U 的 dp_dec[k] 的总和，其中 dp_dec[k] 是以 k 结尾的严格递减子序列的数量，但仅考虑索引在 [i+1, n-1] 范围内的元素。
但是 dp_dec[k] 是全局的，可能包含索引在 i 之前或之后的元素，但当我们计算 dp_dec[k] 时，对于 k > i，它可能包含索引在 [0, k] 之间的元素，但我们需要只包含索引在 [i+1, n-1] 范围内且值小于 arr[i] 的元素。
所以，对于 R[i]，我们需要的是在索引范围 [i+1, n-1] 中，值小于 arr[i] 的局部定义。
定义后缀的 dp_dec。
由于我们需要对每个 i 计算 R[i]，并且 i 在减少，所以最好从右向左处理。
定义 dp_dec_right[i] 为在索引范围 [i, n-1] 中，以 i 结尾的严格递减子序列的数量，但值小于某个值，但我们需要的是子序列的数量，而不是以 i 结尾的。
对于 R[i]，在索引范围 [i+1, n-1] 中，值小于 arr[i] 的严格递减子序列的数量。
令 V = {k | i+1 <= k <= n-1 且 arr[k] < arr[i]}
那么 R[i] = 1 + 所有 k 属于 V 的 dec_local[k] 的总和，其中 dec_local[k] 是在 [i+1, n-1] 中，以 k 结尾的严格递减子序列的数量，但只考虑值小于 arr[i] 的元素，但既然 V 中的元素值都小于 arr[i]，所以我们可以定义该范围内的局部 dp_dec。
但为了高效，我们可以使用树。
类似左侧，但用于递减。
对于右侧部分，定义 S_dec(i) 为所有满足 k > i 且 arr[k] < arr[i] 的 dp_dec[k] 的总和，但 dp_dec[k] 是全局的，并且可能包含值大于 arr[i] 的元素，但当我们包含 k 时，arr[k] < arr[i]，并且 dp_dec[k] 只包含值小于 arr[k] 的序列，因此所有值都小于 arr[k] < arr[i]，所以没问题。
定义全局的 dp_dec[i]，如上所述：dp_dec[i] = 1 + 所有满足 j < i 且 arr[j] > arr[i] 的 dp_dec[j] 的总和
但对于 R[i]，我们需要在 [i+1, n-1] 中，值小于 arr[i] 的递减子序列的数量。
所以，对于 k > i 且 arr[k] < arr[i]，以 k 结尾的递减子序列的数量是 dp_dec[k]，但 dp_dec[k] 可能包含索引小于 i 的元素，但值上，由于 arr[k] < arr[i]，并且序列是递减的，所以所有元素的值都小于 arr[k] < arr[i]，所以它们都小于 arr[i]，但索引可能小于 i，而我们需要索引在 [i+1, n-1] 之间。
问题：在 dp_dec[k] 中，序列可能包含索引在 i 之前的元素，但 R[i] 要求所有元素索引在 i 之后。
所以，对于 R[i]，我们不能使用全局的 dp_dec，因为它包含索引在 i 之前的元素。
例如，假设 k > i，arr[k] < arr[i]，全局 dp_dec[k] 包括一个序列，其中包含索引 j < i 且 arr[j] > arr[k] 的元素，但 j < i，所以对于 R[i]，我们只想要索引 >= i+1 的元素，因此该序列无效，因为它包含索引小于 i 的元素。
所以，对于 R[i]，我们需要在索引范围 [i+1, n-1] 中定义局部递减子序列，只使用该范围内的元素。
类似地，对于 L[i]，在 [0, i-1] 中，我们使用索引在 0 到 i-1 之间的元素，所以没问题，因为当我们计算 L[i] 时，只考虑 j < i，所以索引在 i 之前。
但对于 R[i]，索引在 i 之后，所以我们需要后缀的局部定义。
所以，对于右侧部分，我需要单独处理。
让我定义后缀的 dp。
让我从右向左处理数组。
定义 dp_dec_suffix[i] 为在索引范围 [i, n-1] 中，以 i 结尾的严格递减子序列的数量。
那么，对于每个 i，dp_dec_suffix[i] = 1 + 所有满足 j > i 且 arr[j] < arr[i] 的 dp_dec_suffix[j] 的总和？等等。
对于以 i 结尾的递减子序列，索引递增，值递减，所以对于在 i 之后的元素，索引 j > i，但值 arr[j] < arr[i]，并且序列是递减的，所以我们需要 arr[j] < arr[i]，然后我们可以将 i 放在前面？等等。
序列：如果索引递增，值递减，那么对于以 i 结尾的子序列，前一个元素必须在左侧，索引更小，但值更大。
但对于后缀 [i, n-1]，如果我们想要以 i 结尾的递减子序列，我们需要在 i 之后、索引大于 i 的元素，但值更小，这样我们才能附加在 i 之后？不是。
定义：子序列的索引序列为 p1, p2, ..., pt，其中 p1 < p2 < ... < pt，并且 arr[p1] > arr[p2] > ... > arr[pt]。
如果序列以 i 结尾，则 pt = i。
那么前一个元素 pt-1 必须满足 pt-1 < pt 且 arr[pt-1] > arr[pt]，并且 pt-1 在范围内。
对于后缀 [i, n-1]，索引都 >= i，所以对于以 i 结尾的子序列，它只能是单个元素，或者包含索引在 i 和 j 之间的元素，其中 j > i，但值 arr[j] > arr[i]？不是。
例如，在 [i, n-1] 中，一个子序列：k, i，其中 k > i，但索引 k > i，所以序列是 k 然后 i，但索引递增，k < i？k > i，所以索引顺序是 k, i，但 k > i，所以索引是递减的，但子序列必须保持原始顺序，所以索引必须递增，因此我们无法在子序列中先有 k 再有 i，如果 k > i 的话。
错误。
子序列中元素的顺序：索引必须递增，所以对于索引，如果 p < q，则 arr[p] 在子序列中出现在 arr[q] 之前。
所以对于严格递减子序列，索引递增，值递减，所以对于两个元素，如果 j < k，则 arr[j] > arr[k]。
对于以 i 结尾的子序列，索引序列为 ... , j, i，其中 j < i，并且 arr[j] > arr[i]。
但在后缀 [i, n-1] 中，所有索引都 >= i，所以对于以 i 结尾的子序列，它只能是单个元素，因为如果还有另一个元素，它必须在 i 之后，索引更大，但在子序列中，它会在 i 之后，所以 i 不是结尾。
在索引范围 [i, n-1] 中，以 i 结尾的子序列意味着没有元素在 i 之后，或者序列以 i 结尾。
但如果我们只取 [i, n-1] 中的元素，并且以 i 结尾，那么 i 必须是子序列中的最后一个索引，所以所有其他元素必须在 i 之前，但索引 >= i，所以只有 i 本身是可能的，或者索引在 i 之后，但索引更大，所以它们会在子序列中出现在 i 之后，因此 i 就不是结尾。
因此，在索引范围 [i, n-1] 中，唯一以 i 结尾的子序列就是单个元素 [i] 本身，因为没有更早的索引。
所以 dp_dec_suffix[i] = 1 对于所有 i，如果我们只考虑该后缀，但这样就没意义了。
对于递减子序列，在范围 [i, n-1] 中，以 i 结尾的序列，但由于索引 >= i，并且索引递增，i 是可能的最小索引，所以它必须是子序列中的第一个元素，而不是最后一个。
我搞错了“以 i 结尾”的意思。
在子序列中，“以 i 结尾”意味着在子序列中，i 是最后一个元素，所以索引上，所有其他元素都小于 i。
但对于后缀 [i, n-1]，索引都 >= i，所以如果子序列以 i 结尾，则不能有索引 > i 的元素，因为它们在子序列中会在 i 之后。
所以，对于后缀 [i, n-1]，以 i 结尾的子序列只能是 {i} 本身，因为任何其他元素都会在 i 之后。
因此，对于范围 [i, n-1]，严格递减子序列的数量不能定义为以索引结尾，因为“结尾”索引是较小的，但范围从 i 开始。
更好的方式是从左到右处理递减序列，但索引递增。
对于严格递减子序列，索引递增，值递减，所以序列从左到右是递减的。
所以对于范围 [L, R]，递减子序列的数量可以通过从右向左处理来计算，其中“以 i 开始”之类的。
定义 dp_dec_start[i] 为在索引范围 [i, n-1] 中，以 i 开头的严格递减子序列的数量。
那么，对于每个 i，dp_dec_start[i] = 1 + 所有满足 j > i 且 arr[j] < arr[i] 的 dp_dec_start[j] 的总和
因为我们可以将 i 放在以 j 开头的子序列前面，前提是 arr[i] > arr[j]。
此外，还有仅包含 i 的子序列。
然后，对于索引范围 [i, n-1] 的所有递减子序列的数量是 1 + 所有 k 属于 [i, n-1] 的 dp_dec_start[k] 的总和，但等等。
所有递减子序列的数量包括空序列和所有以某个 k 开头的序列。
所以对于范围 [L,R]，dec_sub(L,R) = 1 + 所有 k 属于 [L,R] 的 dp_dec_start[k] 的总和
其中 dp_dec_start[k] 是以 k 开头的递减子序列的数量。
对于 R[i]，我们需要在 [i+1, n-1] 中，值小于 arr[i] 的递减子序列的数量。
所以，令 W = {k | i+1 <= k <= n-1 且 arr[k] < arr[i]}
那么 R[i] = 1 + 所有 k 属于 W 的 dp_dec_start[k] 的总和
其中 dp_dec_start[k] 是在范围 [i+1, n-1] 中，以 k 开头的递减子序列的数量，但值小于 arr[i]，但既然 W 中的元素值都小于 arr[i]，并且对于 dp_dec_start[k]，所有元素值都小于 arr[k] < arr[i]，所以可以。
但 dp_dec_start[k] 是全局的，用于后缀 [k, n-1]，但我们需要范围是 [i+1, n-1]，所以对于 k > i，后缀 [k, n-1] 是 [i+1, n-1] 的子集，因此可以，但 dp_dec_start[k] 包含的元素索引 >= k > i，所以都在 [i+1, n-1] 范围内，所以对于 R[i]，当我们取 k 属于 W 时，dp_dec_start[k] 只使用索引 >= k > i 的元素，因此所有索引都在 [i+1, n-1] 中，且值小于 arr[k] < arr[i]，所以符合 R[i] 的要求。
因此，R[i] = 1 + 所有满足 k > i 且 arr[k] < arr[i] 的 dp_dec_start[k] 的总和
类似地，对于左侧部分，L[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
其中 dp_inc[j] 是以 j 结尾的递增子序列的数量。
现在，对于 dp_inc，我们使用标准 DP 和 Fenwick 树，从 left to right。
对于 dp_dec_start，我们使用从 right to left 的 DP。
首先，定义 dp_inc[i]：以索引 i 结尾的严格递增子序列的数量。
dp_inc[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
这可以通过在值上使用 Fenwick 树或线段树来实现，在遍历时进行点更新和范围查询。
类似地，对于 dp_dec_start[i]：以索引 i 开头的严格递减子序列的数量。
dp_dec_start[i] = 1 + 所有满足 j > i 且 arr[j] < arr[i] 的 dp_dec_start[j] 的总和
这可以通过从右向左遍历，使用另一棵树来实现。
然后，对于每个 i，L[i] = 1 + 所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和
但所有满足 j < i 且 arr[j] < arr[i] 的 dp_inc[j] 的总和正是我们在计算 dp_inc[i] 时得到的 S_inc(i)
并且由于 dp_inc[i] = 1 + S_inc(i)，所以 S_inc(i) = dp_inc[i] - 1
因此 L[i] = 1 + S_inc(i) = 1 + (dp_inc[i] - 1) = dp_inc[i]
L[i] = dp_inc[i]？
但 dp_inc[i] 是以 i 结尾的递增子序列的数量，而 L[i] 是 [0, i-1] 中值小于 arr[i] 的所有递增子序列的数量。
例如，假设 i=0，那么 [0, -1] 为空，所以 L[0] = 1（空序列）
dp_inc[0] = 1（仅包含单个元素 [0]）
所以 L[0] =1，dp_inc[0] =1，相同。
对于 i=1，arr 有两个元素。
假设 arr = [1,2]
对于 i=1，L[1] = 在 [0,0] 中值小于 arr[1]=2 的递增子序列的数量：索引 0，值 1<2，所以子序列有：空序列，[1]，所以 L[1] = 2
dp_inc[1]：以 1 结尾的递增子序列的数量： [2], [1,2]，所以是 2。
而 S_inc(1) = 所有满足 j<1 且 arr[j]<2 的 dp_inc[j] 的总和：j=0，dp_inc[0]=1，所以 S_inc(1) =1，L[1] =1 + S_inc(1) =1+1=2，dp_inc[1] =1 + S_inc(1) =2。
所以 L[i] = dp_inc[i]？但 dp_inc[i] 是以 i 结尾的，而 L[i] 是前缀中值较小的子序列数量。
在 L[i] 中，子序列不能包含 i，只包含索引 < i 且值 < arr[i] 的元素。
在 dp_inc[i] 中，它包含 i，但在计算中，对于 L[i]，当 i 是最大值时，我们不包含 i，只包含左侧部分。
在表达式 L[i] = 1 + sum_{j< i, arr[j]<arr[i]} dp_inc[j] 中，而 dp_inc[j] 是以 j 结尾的，j < i，所以不包含 i。
在例子中，对于 i=1，L[1] =2，包括空序列和 [1]。
dp_inc[1] =2，包括 [2] 和 [1,2]，但 [2] 包含 arr[1]，而 L[1] 只包含索引 <1 的元素，所以不包含 arr[1]。
所以 L[i] 和 dp_inc[i] 不同，但数值上，对于 i=1，L[1]=2，dp_inc[1]=2，但 L[1] 包含 [1]，它是以 j=0 结尾的，而 dp_inc[1] 包含 [2] 和 [1,2]。
所以数值相同，但含义不同。
另一个例子，arr = [3,1]，i=1。
L[1]：在 [0,0] 中值小于 arr[1]=1 的 j：arr[0]=3 >1，所以没有 j，因此 L[1] =1（只有空序列）
dp_inc[1]：以 1 结尾的递增子序列： [1]，所以是 1。
S_inc(1) = 所有满足 j<1 且 arr[j]<1 的 dp_inc[j] 的总和：j=0，arr[0]=3>1，所以没有，总和为0，L[1] =1 +0 =1。
dp_inc[1] =1 + S_inc(1) =1+0=1。
所以 L[i] = dp_inc[i] 在数值上成立，但 dp_inc[i] 包含以 i 结尾的序列，而 L[i] 不包含 i，但数值上，由于 S_inc(i) 和 dp_inc[i] 的关系，L[i] = dp_inc[i]。
L[i] =1 + S_inc(i)，而 dp_inc[i] =1 + S_inc(i)，所以是的，L[i] = dp_inc[i]。
但 L[i] 是 [0,i-1] 中值小于 arr[i] 的递增子序列的数量，而 dp_inc[i] 是以 i 结尾的递增子序列的数量，它们数值相同，但概念不同。
在计算中，我们可以使用 L[i] = dp_inc[i]，但 dp_inc[i] 依赖于 S_inc(i)，而 S_inc(i) 是 j<i 的 dp_inc[j] 的总和。
对于右侧部分，类似地，R[i] = 1 + 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
而 dp_dec_start[k] 是以 k 开头的递减子序列的数量。
现在，定义 S_dec(i) = 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
那么 R[i] = 1 + S_dec(i)
但 S_dec(i) 是用于 R[i] 的总和。
现在，对于原始问题，对于每个 i，以 i 为最大值的子序列数量是 L[i] * R[i]
其中 L[i] = dp_inc[i] 如上所述
但 L[i] 是左侧部分的数量，其中包括空序列，并且所有元素值 < arr[i]，索引 < i。
类似地，R[i] 是右侧部分的数量。
然后，对于每个 i，贡献为 L[i] * R[i]
然后，总数量为 sum_{i=0}^{n-1} L[i] * R[i]
但 L[i] = dp_inc[i]，而 dp_inc[i] 是以 i 结尾的递增子序列的数量，但在我们的情况下，对于固定 i，L[i] 用于左侧部分，不包含 i。
在贡献中，对于最大值在 i 的情况，我们有 L[i] 和 R[i] 的选择，然后最大值在 i。
所以，是的。
现在，我们需要计算每个 i 的 dp_inc[i] 和 dp_dec_start[i]。
首先，对于 dp_inc：从左到右处理。
我们需要一个 Fenwick 树或线段树，用于值域上的范围求和。
由于值可能很大，进行坐标压缩。
类似地，对于 dp_dec_start，从右到左处理。
然后，对于每个 i，L[i] = dp_inc[i]
但 dp_inc[i] 是以 i 结尾的递增子序列的数量，而 L[i] 是 [0, i-1] 中值小于 arr[i] 的递增子序列的数量，但如上所述，它们在数值上相等。
在
代码中，我们可以设置 L[i] = dp_inc[i]
类似地，对于右侧，R[i] = 1 + 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
现在，对于每个 i，我们需要计算 S_dec(i) = 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
这可以通过使用 Fenwick 树从右向左处理，在值域上查询。
但在计算 R[i] 时，当我们在 i 时，我们需要所有 k>i 的 dp_dec_start[k]，但 dp_dec_start[k] 是用于 k 的，所以当我们处理到 i 时，k>i 的 dp_dec_start[k] 可能尚未计算，如果我们是从左到右处理，但我们需要从右到左处理 dp_dec_start。
顺序：首先，计算 dp_inc 和 dp_dec_start 数组。
对于 dp_inc：从左到右遍历，对于每个 i，查询值域 [0, arr[i]-1] 的 dp_inc[j] 的总和，然后设置 dp_inc[i] = 1 + 该总和，并更新树在位置 arr[i] 的值，增加 dp_inc[i]。
类似地，对于 dp_dec_start：从右到左遍历，对于每个 i，查询值域 [0, arr[i]-1] 的 dp_dec_start[j] 的总和（对于 j>i），但等等。
dp_dec_start[i] = 1 + 所有满足 j>i 且 arr[j] < arr[i] 的 dp_dec_start[j] 的总和
所以对于值域，我们需要查询值小于 arr[i] 的索引的 dp_dec_start 的总和。
由于索引 j>i，并且我们从右向左遍历，当我们处理 i 时，所有 j>i 的 dp_dec_start 已经计算并更新到树中。
所以，从右向左，初始化树。
对于每个 i，从大到小，查询值域 [0, arr[i]-1] 的 dp_dec_start 的总和，然后 dp_dec_start[i] = 1 + 该总和，然后更新树在位置 arr[i] 的值，增加 dp_dec_start[i]。
然后，在计算了 dp_inc 和 dp_dec_start 之后，对于每个 i，我们有 L[i] = dp_inc[i]
但 L[i] 用于左侧部分，而 dp_inc[i] 包含 i，但数值上没问题。
然后 R[i] = 1 + 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
现在，所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和，可以通过在值域上使用 Fenwick 树查询，但我们需要在固定 i 时进行查询。
在计算了所有 dp_dec_start 之后，我们可以为后缀的 dp_dec_start 值构建一棵树。
由于我们需要对每个 i 进行查询，并且 i 是变化的，所以最好在计算了所有 dp_dec_start 之后，使用一棵 Fenwick 树来存储值，然后按索引顺序处理 i，但值域是值。
对于每个 i，要计算 S_dec(i) = 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和
这可以通过在值域上使用 Fenwick 树来实现，其中存储了所有 k 的 dp_dec_start[k]，但仅限于 k>i，因此我们需要在查询时排除 k<=i 的值，但值域是值，而不是索引。
所以，我们需要将索引和值联系起来。
一个方法是：首先，按索引顺序，但为了后缀，我们可以从右向左处理。
在从右向左计算 dp_dec_start 的过程中，当我们处理 i 时，所有 j>i 的 dp_dec_start 已经更新到树中，所以对于 S_dec(i)，它类似于在计算 dp_dec_start[i] 时的查询，但 S_dec(i) 是用于 R[i] 的，而查询是用于 dp_dec_start[i] 的。
对于 dp_dec_start[i]，我们查询所有满足 j>i 且 arr[j]<arr[i] 的 dp_dec_start[j] 的总和，但 j>i 且 arr[j]<arr[i]，所以该总和是 S 的一部分。
但用于 R[i]，S_dec(i) = 所有满足 k>i 且 arr[k]<arr[i] 的 dp_dec_start[k] 的总和，这正是我们在计算 dp_dec_start[i] 时进行的相同查询。
设 T_dec(i) = 所有满足 j>i 且 arr[j]<arr[i] 的 dp_dec_start[j] 的总和
那么 dp_dec_start[i] = 1 + T_dec(i)
而 R[i] = 1 + S_dec(i) = 1 + T_dec(i) 因为 S_dec(i) = T_dec(i)
所以 R[i] = 1 + T_dec(i)
但 dp_dec_start[i] = 1 + T_dec(i)，所以 R[i] = dp_dec_start[i]
类似地，对于左侧，L[i] = dp_inc[i]
所以，对于每个 i，L[i] = dp_inc[i]，R[i] = dp_dec_start[i]
那么以 i 为最大值的子序列数量是 L[i] * R[i] = dp_inc[i] * dp_dec_start[i]
然后总数量是 sum_{i} dp_inc[i] * dp_dec_start[i] mod 998244353
在左侧部分，L[i] = dp_inc[i] 是 [0,i-1] 中值小于 arr[i] 的递增子序列的数量，其中包括以索引 j < i 结尾的子序列，所有值都小于 arr[i]。
右侧部分也是类似情况。
在贡献中，对于最大值在 i 的情况，我们有 L[i] 种方式选择左侧部分，R[i] 种方式选择右侧部分，然后最大值在 i，所以是 L[i] * R[i]。
而 L[i] 和 R[i] 都包括空序列。
例如，如果左右都为空，那么子序列就是 [i] 本身，只有一个元素。
如果左边有元素，右边为空，等等。
所以是的。
现在，在计算中，我们需要在值域上使用 Fenwick 树，所以首先对值进行坐标压缩。
步骤：
1. 对数组 arr 进行坐标压缩，这样值在 1 到 m 之间（1-indexed 用于 Fenwick 树）。
2. 初始化两个 Fenwick 树，一个用于递增，一个用于递减。
3. 计算 dp_inc：
- 从左到右遍历 i
- 查询值域 [1, arr[i]-1] 的 dp_inc 总和，令 sum_inc = query(1, comp(arr[i])-1)
- dp_inc[i] = 1 + sum_inc
- 在树中更新位置 comp(arr[i])，增加 dp_inc[i]
4. 计算 dp_dec_start：
- 从右到左遍历 i
- 查询值域 [1, arr[i]-1] 的 dp_dec_start 总和，令 sum_dec = query(1, comp(arr[i])-1)
- dp_dec_start[i] = 1 + sum_dec
- 在树中更新位置 comp(arr[i])，增加 dp_dec_start[i]
5. 对于每个 i，计算贡献：contribution[i] = dp_inc[i] * dp_dec_start[i] mod mod
6. 总和 = 所有 contribution[i] 的总和 mod mod
7. 输出总和
但 dp_inc[i] 和 dp_dec_start[i] 可能很大，所以我们在计算时取模。
此外，对于空序列，当没有元素时，但在这个问题中，子序列可能为空吗？可能不行，因为子序列通常至少包含一个元素，但在我们的情况中，对于单元素子序列，它应该被包含。
例如，单个元素：最大值就是它自己，左边和右边都为空，所以 L[i] 包含空序列，R[i] 也包含空序列，因此 L[i] * R[i] 包括 1*1 =1 对于单个元素。
在总和中，对于每个 i，当子序列只有 [i] 时，它被包含在 i 的贡献中。
如果子序列有多个元素，但最大值在 i，等等。
但子序列至少有一个元素，所以当 L[i] 和 R[i] 都为空时，子序列为 [i]，没问题。
但空子序列呢？它没有最大值，所以不被包含，这很好，因为在我们的总和中，我们没有添加空序列。
在定义中，L[i] 包括空序列，但当我们乘以 R[i] 时，对于每个 i，我们得到的是以 i 为最大值的非空子序列，所以所有子序列至少有一个元素。
而空子序列不被包含，因为没有最大值。
所以，在总和中，我们得到了所有满足条件的非空子序列。
现在，在计算中，对于索引，我们需要处理边界。
在 Fenwick 树中，我们使用 1-indexed。
另外，当 arr[i] 是最小值时，查询 [1, arr[i]-1] 可能为空，所以 sum=0。
类似地，当是最大值时。
在压缩中，值从 1 开始。
在左侧部分，对于 i=0，没有左边元素，所以 L[0] 应该是 1（空序列），并且 dp_inc[0] =1，因为单个元素。
类似地，对于 i=n-1，没有右边元素，R[n-1] =1。
在
代码中，它应该可以工作。
现在，关于取模：mod = 998244353
所有操作都要取模。
现在，在树中，更新和查询也要取模。
最后，输出总和。
但让我用一个小例子来确认。
假设数组： [1]
n=1
i=0: L[0] =1 (空序列), R[0]=1, 贡献=1*1=1
子序列: [1] 应该成立。
是的。
另一个例子: [1,2]
i=0: 最大值在0, 左边: 空, L[0]=1
右边: 索引1, arr[1]=2>1? 但值必须 < arr[0]=1, arr[1]=2>1, 所以没有元素, R[0]=1 (空)
贡献: 1*1=1
但子序列 [1] 是成立的。
i=1: 最大值在1, 左边: 索引0, arr[0]=1<2, 所以递增子序列: 空, [1], 所以 L[1]=2
右边: 空, R[1]=1
贡献: 2*1=2
子序列: [2] 和 [1,2]
[1,2]: 最大值在2, 左边 [1] 递增, 右边空。
是的。
总子序列: 对于 i=0: [1], i=1: [2], [1,2], 所以总共3个。
但 [1] 在 i=0 时计数，[2] 在 i=1 时计数，[1,2] 也在 i=1 时计数。
现在，还有更多吗？[1] 是单独的吗？是的。
但子序列 [1] 和 [2] 是单元素，[1,2] 是双元素。
全部满足条件。
另一个例子： [2,1]
i=0：最大值在 0，左边：空，L[0]=1
右边：索引 1，arr[1]=1<2，所以对于 R[0]，在 [1,1] 中，值小于 2 的递减子序列：索引 1，值 1<2，递减子序列：空，[1]，所以 R[0]=2？但等等。
对于 R[0]，在索引 [1,1] 中，值小于 arr[0]=2 的元素，只有索引 1，值 1<2。
严格递减子序列：空序列，[1]，所以 R[0]=2
然后贡献：L[0] * R[0] = 1 * 2 = 2
子序列：当最大值在 0 时，[2] 本身，以及 [2,1]，其中左边为空，右边为 [1]。
[2,1]：最大值是 2，左边为空，右边 [1] 是降序，是的。
i=1：最大值在 1，左边：索引 0，arr[0]=2>1？但值必须 < arr[1]=1，arr[0]=2>1，所以没有元素，L[1]=1（空）
右边：空，R[1]=1
贡献：1*1=1，子序列 [1]
总贡献：i=0 时为 2（[2] 和 [2,1]），i=1 时为 1（[1]），所以总共 3 个子序列。
[2]、[1]、[2,1]。
全部合理。
在 [2,1] 中，当 i=0 时，R[0]=2，因为右边部分有 [1] 和空序列。
是的。
现在，在算法中，对于 [2,1]，压缩值：假设值 1 和 2，comp: 1->1, 2->2。
dp_inc：
i=0：arr[0]=2，查询值 [1,1]（因为 comp(arr[i])-1=2-1=1），值 1 到 1 的总和，但还没有值，sum_inc=0，dp_inc[0]=1+0=1，在位置 2 更新值为 1。
i=1：arr[1]=1，查询 [1,0] 为空，sum_inc=0，dp_inc[1]=1+0=1，在位置 1 更新值为 1。
dp_dec_start：
i=1：arr[1]=1，查询值 [1,0] 为空，sum_dec=0，dp_dec_start[1]=1+0=1，在位置 1 更新值为 1。
i=0：arr[0]=2，查询 [1,1]（comp=1 到 1），位置 1 的总和是 dp_dec_start[1]=1，所以 sum_dec=1，dp_dec_start[0]=1+1=2，在位置 2 更新值为 2。
然后对于每个 i 的贡献：i=0：dp_inc[0] * dp_dec_start[0] = 1 * 2 = 2
i=1：1 * 1 = 1
总和 = 3，正确。
另一个测试： [1,3,2]
子序列：单元素：[1],[3],[2]
两个元素：[1,3]，最大值3在索引1，左边[1]递增，右边无。
[1,2]，但最大值？如果子序列是[1,2]，最大值是2，左边[1]在索引0<索引1？索引：索引0和2，但顺序：在子序列中，位置：第一个元素索引0，值1，然后索引2，值2，所以最大值是2在结尾，左边[1]递增，右边无。所以最大值在索引2？索引是0和2，最大值在索引2。
在完整数组中，索引0:1，1:3，2:2
子序列[1,2]：元素索引0和2，值1和2，最大值是2在索引2，左边[1]递增（索引0<2），右边无。
[3,2]：索引1和2，值3和2，最大值3在索引1，左边无，右边[2]递减。
[1,3,2]：最大值3在索引1，左边[1]递增，右边[2]递减。
现在，三个元素：[1,3,2] 如上所述。
还有，[1,2] 如上所述。
现在，列出所有满足条件的子序列：
- 单个元素：全部三个：[1],[3],[2]
- 两个元素：[1,3]：最大值3在索引1，左边[1]，右边无
[3,2]：最大值3在索引1，左边无，右边[2]
[1,2]：最大值2在索引2，左边[1]，右边无
[2] 是单个元素。
[1,3] 和 [3,2] 是双元素。
[1,2] 是双元素，索引0和2。
- 三个元素：[1,3,2]
现在，还有更多吗？[1,3] 等等。
现在，在算法中：
arr = [1,3,2]
压缩：值 1,2,3 对应索引 1,2,3？值：1,3,2，排序后：1,2,3，所以 comp: 1->1, 2->2, 3->3？但 3 在索引1，2 在索引2。
值：设 v:1,3,2，排序后为 1,2,3，所以 comp[1]=1, comp[3]=3, comp[2]=2？索引：位置0的值是1，位置1的值是3，位置2的值是2。
压缩后：值：pos0:1, pos1:3, pos2:2，所以压缩值：c[0]=1, c[1]=3, c[2]=2。
但值映射：1->1, 2->2, 3->3。
dp_inc：
i=0：c[0]=1，查询 [1,0] 为空，sum=0，dp_inc[0]=1，在树中位置1更新值为1
i=1：c[1]=3，查询 [1,2]（值1到2），位置1的总和是1（来自i=0），所以 sum_inc=1，dp_inc[1]=1+1=2，在位置3更新值为2
i=2：c[2]=2，查询 [1,1]（值1），位置1的总和是1，sum_inc=1，dp_inc[2]=1+1=2，在位置2更新值为2
现在 dp_dec_start：
从右到左
i=2：c[2]=2，查询 [1,1]（值1），但还没有，sum_dec=0，dp_dec_start[2]=1，在树中位置2更新值为1
i=1：c[1]=3，查询 [1,2]（值1到2），位置1没有值？位置2有值1（来自i=2），所以值1到2的总和：位置2的值是1，但值2对应位置2？树中值：位置2的值是1，但值范围：查询值<=2-1=2？查询值 [1,2]，值1和2。
位置：值1：无，值2：在位置2有1，所以总和=1，所以 sum_dec=1，dp_dec_start[1]=1+1=2，在位置3更新值为2
i=0：c[0]=1，查询 [1,0] 为空，sum_dec=0，dp_dec_start[0]=1+0=1，在位置1更新值为1
现在，贡献：
i=0：L[0] * R[0] = dp_inc[0] * dp_dec_start[0] =1 *1=1 // [1]
i=1：2 * 2=4 // 对于最大值在1：子序列：[3], [1,3], [3,2], [1,3,2]
[3]：左边空，右边空
[1,3]：左边 [1]，右边空
[3,2]：左边空，右边 [2]
[1,3,2]：左边 [1]，右边 [2]
是的，四个。
i=2：2 *1=2 // 对于最大值在2：子序列 [2] 和 [1,2]
[2]：左边空，右边空
[1,2]：左边 [1]，右边空
是的。
总和：i=0:1，i=1:4，i=2:2，总共7。
但之前我列出了子序列：[1]、[3]、[2]、[1,3]、[3,2]、[1,2]、[1,3,2]，一共7个。
全部覆盖。
在 i=1 时，贡献为4，包括 [3] 和组合。
完美。
所以算法正确。
现在，在
代码中，我们需要实现 Fenwick 树。
由于问题要求生成相关问题，但首先，我需要提供解决方案。
用户要求
代码，但在这个上下文中，我应该描述算法。
用户说“生成相关问题”，但在最后。
首先，回答问题。
所以，总结如下：
要计算满足条件的子序列数量，其中有一个唯一的最大值，其左侧严格递增，右侧严格递减，结果对 998244353 取模。
我们可以使用动态规划和 Fenwick 树（或线段树）在 O(n log n) 时间内解决。
步骤：
1. 对数组值进行坐标压缩。
2. 计算 dp_inc[i]：表示以索引 i 结尾的严格递增子序列的数量。
- 使用 Fenwick 树，从左到右遍历。
- 对于每个 i，查询值在 [1, arr[i]-1] 范围内的 dp_inc[j] 的总和（j < i，但由值约束隐含）。
- dp_inc[i] = 1 + query_result
- 在树中位置 arr[i] 处更新 dp_inc[i]
3. 计算 dp_dec_start[i]：表示以索引 i 开头的严格递减子序列的数量。
- 使用另一个 Fenwick 树，从右向左遍历。
- 对于每个 i，查询值在 [1, arr[i]-1] 范围内的 dp_dec_start[j] 的总和（j > i）。
- dp_dec_start[i] = 1 + query_result
- 在树中位置 arr[i] 处更新 dp_dec_start[i]
4. 对于每个索引 i，贡献 = dp_inc[i] * dp_dec_start[i] mod mod
5. 总答案 = 所有贡献之和 mod mod
6. 输出答案
在
代码中，注意取模操作。
现在，对于相关问题，用户要求生成相关问题。
最后。
首先，提供解决方案。</think>### 计算满足丸山定义的子序列数量
丸山定义要求子序列中有一个唯一的最大值，最大值左边的元素（在子序列中）严格升序，最大值右边的元素（在子序列中）严格降序。子序列必须非空，且元素顺序保持原数组顺序。结果需对 998244353 取模。
#### 算法思路
1. **问题分析**：
- 子序列必须有一个唯一的最大值（即子序列中最大值出现且仅出现一次）。
- 最大值左边的子序列（元素索引小于最大值索引）必须严格升序。
- 最大值右边的子序列（元素索引大于最大值索引）必须严格降序。
- 子序列可以为单个元素（此时左边和右边为空）。
- 数组长度 \( n \) 可能很大（例如 \( 10^5 \)，因此需要 \( O(n \log n) \) 解法。
2. **关键观察**：
- 对于每个位置 \( i \)（作为最大值），计算以 \( arr[i] \) 为最大值的子序列数量。
- 左部分（索引 \( < i \)）：所有严格升序子序列（元素值 \( < arr[i] \)，包括空序列）。
- 右部分（索引 \( > i \)）：所有严格降序子序列（元素值 \( < arr[i] \)，包括空序列）。
- 贡献为 \( L[i] \times R[i] \)，其中 \( L[i] \) 是左部分数量，\( R[i] \) 是右部分数量。
- 总数量为所有 \( i \) 的贡献之和。
3. **动态规划与 Fenwick 树**：
- **坐标压缩**：由于值可能很大，先压缩值到 \( [1, m] \)（1-indexed），以优化 Fenwick 树操作。
- **dp_inc[i]**：以索引 \( i \) 结尾的严格递增子序列数量（用于左部分计算）。
- 从左到右遍历，用 Fenwick 树查询值域 \( [1, arr[i]-1] \) 的 \( dp\_inc[j] \) 总和。
- \( dp\_inc[i] = 1 + \text{query\_result} \)，然后更新树。
- **dp_dec_start[i]**：以索引 \( i \) 开头的严格递减子序列数量（用于右部分计算）。
- 从右到左遍历，用 Fenwick 树查询值域 \( [1, arr[i]-1] \) 的 \( dp\_dec\_start[j] \) 总和（\( j > i \))。
- \( dp\_dec\_start[i] = 1 + \text{query\_result} \)，然后更新树。
- **贡献计算**：\( L[i] = dp\_inc[i] \), \( R[i] = dp\_dec\_start[i] \)，贡献为 \( \text{contribution}[i] = dp\_inc[i] \times dp\_dec\_start[i] \mod 998244353 \)。
- **总答案**：对所有 \( i \) 的贡献求和。
4. **复杂度**：
- 时间：\( O(n \log n) \)（坐标压缩 \( O(n \log n) \)，Fenwick 树操作 \( O(\log n) \) 每元素）。
- 空间：\( O(n) \).
####
代码实现
以下是 Python 实现。Fenwick 树用于高效范围查询和点更新。
```python
mod = 998244353
class Fenw:
def __init__(self, size):
self.n = size
self.tree = [0] * (self.n + 1)
def update(self, index, delta):
while index <= self.n:
self.tree[index] = (self.tree[index] + delta) % mod
index += index & -index
def query(self, index):
s = 0
while index:
s = (s + self.tree[index]) % mod
index -= index & -index
return s
def range_query(self, l, r):
if l > r:
return 0
res = self.query(r) - self.query(l - 1)
return res % mod
def main():
import sys
data = sys.stdin.read().split()
if not data:
return
n = int(data[0])
arr = list(map(int, data[1:1+n]))
# 坐标压缩
sorted_vals = sorted(set(arr))
comp_map = {}
for idx, val in enumerate(sorted_vals):
comp_map[val] = idx + 1 # 1-indexed
comp_arr = [comp_map[x] for x in arr]
m = len(sorted_vals)
# 初始化 dp_inc 和 Fenwick 树
dp_inc = [0] * n
fenw_inc = Fenw(m)
# 从左到右计算 dp_inc
for i in range(n):
val = comp_arr[i]
# 查询值域 [1, val-1] 的 dp_inc[j] 总和
if val > 1:
sum_inc = fenw_inc.range_query(1, val - 1)
else:
sum_inc = 0
dp_inc[i] = (1 + sum_inc) % mod
fenw_inc.update(val, dp_inc[i])
# 初始化 dp_dec_start 和 Fenwick 树
dp_dec_start = [0] * n
fenw_dec = Fenw(m)
# 从右到左计算 dp_dec_start
for i in range(n-1, -1, -1):
val = comp_arr[i]
# 查询值域 [1, val-1] 的 dp_dec_start[j] 总和 (j > i)
if val > 1:
sum_dec = fenw_dec.range_query(1, val - 1)
else:
sum_dec = 0
dp_dec_start[i] = (1 + sum_dec) % mod
fenw_dec.update(val, dp_dec_start[i])
# 计算每个 i 的贡献和总答案
total = 0
for i in range(n):
contr = (dp_inc[i] * dp_dec_start[i]) % mod
total = (total + contr) % mod
# 确保非负
total %= mod
print(total)
if __name__ == '__main__':
main()
```
####
代码说明
1. **坐标压缩**：将数组值映射到 \( [1, m] \) 以减小 Fenwick 树大小。
2. **Fenwick 树**：支持范围查询和点更新，用于高效计算前缀和。
3. **dp_inc 计算**：
- 从左到右遍历，对于每个 \( i \)，查询值小于 \( arr[i] \) 的 \( dp\_inc[j] \) 总和。
- \( dp\_inc[i] \) 包括以 \( i \) 结尾的子序列（对应左部分数量）。
4. **dp_dec_start 计算**：
- 从右到左遍历，对于每个 \( i \)，查询值小于 \( arr[i] \) 的 \( dp\_dec\_start[j] \) 总和（\( j > i \))。
- \( dp\_dec\_start[i] \) 包括以 \( i \) 开头的子序列（对应右部分数量）。
5. **贡献和总答案**：每个 \( i \) 的贡献为 \( dp\_inc[i] \times dp\_dec\_start[i] \)，总和对 998244353 取模。
#### 示例测试
- 输入: `[1]` 输出: `1` (子序列 `[1]`)
- 输入: `[1,2]` 输出: `3` (子序列 `[1]`, `[2]`, `[1,2]`)
- 输入: `[2,1]` 输出: `3` (子序列 `[2]`, `[1]`, `[2,1]`)
- 输入: `[1,3,2]` 输出: `7` (子序列 `[1]`, `[3]`, `[2]`, `[1,3]`, `[3,2]`, `[1,2]`, `[1,3,2]`)
此算法高效可靠，适用于
大数组[^1]。
扫一扫
4830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
