给你一个长度为 n 的二维整数数组 items 和一个整数 k 。itemsi = profiti categoryi其中 profiti 和 categoryi 分别表示第 i 个项目的利润和类别。现定义 items 的 子序列 的 优雅度 可以用 total_profit + distinct_categories^2 计算其中 total_profit 是子序列中所有项目的利润总和disti

可以使用动态规划来解决这个问题。

首先，我们可以定义一个二维数组 dp，其中 dp[i][j] 表示以第 i 个项目结尾的长度为 j 的子序列的最大优雅度。

对于 dp[i][j]，我们可以考虑两种情况：

1. 不选择第 i 个项目，即 dp[i][j] = dp[i-1][j]
2. 选择第 i 个项目，即 dp[i][j] = dp[i-1][j-1] + profit[i] + count[i]^2，其中 count[i] 表示第 i 个项目的类别数量

最终的结果就是 dp[n][k]，其中 n 表示 items 的长度。

具体的动态规划过程如下：

1. 初始化 dp 数组，dp[i][j] = 0，对于所有的 i 和 j
2. 遍历 items 数组，对于每个项目 items[i]，进行如下操作：
   • 对于 j 从 k 到 1，逆序更新 dp[i][j]，根据上述的状态转移方程计算 dp[i][j] 的值
3. 返回 dp[n][k] 作为最大优雅度的结果

代码实现如下：

def maxElegance(items, k):
    n = len(items)
    dp = [[0] * (k + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        profit, category = items[i - 1]
        count = [0] * (n + 1)
        total_profit = 0

        for j in range(i, 0, -1):
            total_profit += items[j - 1][0]
            count[items[j - 1][1]] += 1

            for x in range(k, 0, -1):
                dp[i][x] = max(dp[i][x], dp[i - 1][x])
                dp[i][x] = max(dp[i][x], dp[i - 1][x - 1] + total_profit + count[items[i - 1][1]] ** 2)

    return dp[n][k]

该算法的时间复杂度为 O(n * k * n)，其中 n 是 items 的长度