3662 最大上升子序列和（dp + 树状数组优化）

1. 问题描述：

给定一个长度为 n 的整数序列 a1，a2，…，an。请你选出一个该序列的严格上升子序列，要求所选子序列的各元素之和尽可能大。请问这个最大值是多少？

输入格式

第一行包含整数 n。第二行包含 n 个整数 a1，a2，…，an。

输出格式

输出最大的上升子序列和。

数据范围

对于前三个测试点，1 ≤ n ≤ 4。
对于全部测试点，1 ≤ n ≤ 10 ^ 5，1 ≤ ai  ≤ 10 ^ 9。

输入样例1：

2
100 40

输出样例1：

100

输入样例2：

4
1 9 7 10

输出样例2：

20
样例解释
对于样例 1，我们只选取 100。对于样例 2，我们选取 1，9，10。
来源：https://www.acwing.com/problem/content/description/3665/

2. 思路分析：

这道题目与1016题的题目是一样的，只是数据范围上有所不同，1016题的数据范围为10 ^ 3，这道题目的数据范围为10 ^ 5，所以不能够直接使用1016题中的做法，我们需要将时间复杂度控制到O(n)或者是O(nlogn)以内，所以需要对1016题中的做法进行优化，一般来说对于一道dp的题目先考虑如何正确做出来，然后再考虑如何优化，很多时候是可以分开考虑的；首先考虑如何做，对于这道题目来说我们可以声明一个一维数组f，其中f[i]表示以ai结尾的严格上升子序列的最大和，因为当前的上升子序列中ai是确定的，所以我们可以看严格上升子序列倒数第二个元素的位置，其中0 <= j < i，根据倒数第二个元素可以将其分为i类(∀aj < ai)，如果ai可以接在aj的后面那么更新一下最大值，在当前i类中取一个max就是以当前ai结尾的严格上升子序列的最大和，状态计算表达式为：f[i] = max(f[i]，f[j] + a[i])（0 <= j < i），根据这个表达式可以发现每一次我们都是在前[0，i - 1]个数中找到一个小于ai的对应的最大的f[j]，在区间[0，i - 1]中找到一个小于ai的最大的f[j]的操作（维护区间最大值）可以使用树状数组，线段树或者splay来解决（spaly比较长不推荐），实际上是维护当前区间的最大值；如果使用树状数组来解决，由于ai最大是10 ^ 9，而且n最多有10 ^ 5所以不可能声明这么大的数组，我们需要对ai进行离散化，离散化之后的数组长度最大为10 ^ 5，离散化其实是将所有的数值映射为连续的下标，我们对当前的数值操作等价于对对应下标的位置进行操作，可以枚举所有的ai，找到ai在离散化数数组xs的对应位置k，然后使用树状数组的query查询操作查询出区间[1，k - 1]中的最大值（注意树状数组的下标是从1开始的，所以一开始的时候需要在离散化数组前面加上一个0这样元素下标可以从1开始避免后面树状数组插入元素的时候出现死循环），相当于前i - 1个数中最大的f[j]，当前的f[i] = f[j] + a[i]，更新一下最大值res，然后将f[i] "插入" 到对应位置，对于这道题目来说其实是更新与i相关位置的树状数组对应位置的最大值（根据题目的要求维护相应位置的值）。

3. 代码如下：

from typing import List


class Solution:
    # tr为树状数组
    tr = None

    def lowbit(self, x: int):
        return x & -x
    
    # 在x位置"加上"v, 根据题目的要求确定维护的是最大/小值或者和进行对应操作, 对于这道题目来说是维护最大值
    def add(self, x: int, v: int, n: int):
        i = x
        while i < n:
            self.tr[i] = max(self.tr[i], v)
            i += self.lowbit(i)

    def query(self, x: int):
        i, res = x, 0
        while i > 0:
            res = max(res, self.tr[i])
            i -= self.lowbit(i)
        return res

    # 二分查找xs中第一个小于等于x的位置, 可以发现一定会找到这个位置
    def get(self, x: int, xs: List[int]):
        # 注意下标是从1开始的
        l, r = 1, len(xs) - 1
        while l < r:
            mid = l + r >> 1
            if xs[mid] >= x:
                r = mid
            else:
                l = mid + 1
        return r

    def process(self):
        n = int(input())
        a = list(map(int, input().split()))
        # f为状态数组, f[i]表示以ai结尾的严格上升子序列的最大和
        f = [0] * (n + 10)
        # xs为离散化之后的数组, 前面加上一个0这样二分查找的时候下标可以从1开始
        xs = [0] + list(set(a))
        xs.sort()
        # 因为最多有xs个元素所以长度声明大一点即可
        self.tr = [0] * (len(xs) + 10)
        res = 0
        for i in range(n):
            k = self.get(a[i], xs)
            f[i] = self.query(k - 1) + a[i]
            res = max(res, f[i])
            # 将f[i]的值插入到对应位置, (其实是更新与位置k有关系的位置的最大值)
            self.add(k, f[i], len(xs) + 10)
        return res


if __name__ == '__main__':
    print(Solution().process())