使用 Python 解题 - 观光景点组合得分问题

一，题目详情

1，问题描述

小R正在研究一组观光景点，每个景点都有一个评分，保存在数组 values 中，其中 valuesi 表示第 i 个观光景点的评分。同时，景点之间的距离由它们的下标差 j - i 表示。

一对景点 (i < j) 的观光组合得分为 valuesi + valuesj + i - j，也就是两者评分之和减去它们之间的距离。

小R想知道，在哪种情况下能够获得观光景点组合的最高得分。

2，测试样例

样例1：

输入： values = [8, 3, 5, 5, 6]

输出： 11

解释：最高得分的组合是 (0, 4)，得分为 8 + 6 + 0 - 4 = 11。

样例2：

输入： values = [10, 4, 8, 7]

输出： 16

解释：最高得分的组合是 (0, 2)，得分为 10 + 8 + 0 - 2 = 16。

样例3：

输入： values = [1, 2, 3, 4, 5]

输出： 8

解释：最高得分的组合是 (3, 4)，得分为 4 + 5 + 3 - 4 = 8。

3，约束条件

• 2 ≤ values.length ≤ 1000
• 1 ≤ valuesi ≤ 1000

二，解题思路

1，问题分析

我们需要找到一对景点 (i < j)，使得 valuesi + valuesj + i - j 最大。这个表达式可以重新排列为 (valuesi + i) + (valuesj - j)。因此，对于每个 j，我们需要找到前面所有 i 中 valuesi + i 的最大值，然后与 valuesj - j 相加，得到当前 j 的最大得分。

2，算法策略

我们可以使用动态规划的思想来解决这个问题：

1. 初始化一个变量 max_so_far 来记录 valuesi + i 的最大值。
2. 遍历数组，对于每个 j，计算当前 j 的 valuesj - j，并与 max_so_far 相加得到当前得分。
3. 更新 max_so_far 为当前 j 的 valuesj + j 和 max_so_far 中的较大值。
4. 在遍历过程中，记录所有得分中的最大值。

3，逐步推演（以样例1为例）

输入 values = [8, 3, 5, 5, 6]，推演过程如下：

步骤	j	valuesj	valuesj - j	max_so_far	current_score	max_score
初始	-	-	-	8 + 0 = 8	-	-∞
1	1	3	3 - 1 = 2	8	8 + 2 = 10	10
2	2	5	5 - 2 = 3	8	8 + 3 = 11	11
3	3	5	5 - 3 = 2	8	8 + 2 = 10	11
4	4	6	6 - 4 = 2	8	8 + 2 = 10	11

最终结果 max_score = 11，与预期一致。

三，代码实现

Python复制

def solution(values: list) -> int:
    if len(values) < 2:
        return 0  # 根据约束条件，这行可能不会执行
    
    max_so_far = values[0] + 0
    max_score = float('-inf')
    
    for j in range(1, len(values)):
        current_score = max_so_far + (values[j] - j)
        if current_score > max_score:
            max_score = current_score
        # 更新max_so_far为当前j作为i时的最大值
        current_i_value = values[j] + j
        if current_i_value > max_so_far:
            max_so_far = current_i_value
    
    return max_score

1，复杂度分析

• 时间复杂度：O(n)

  • 只需一次线性遍历（n为数组长度）

• 空间复杂度：O(1)

  • 仅使用常数级额外空间

2，边界测试

Python复制

if __name__ == '__main__':
    # 常规测试
    print(solution([8, 3, 5, 5, 6]) == 11)
    print(solution([10, 4, 8, 7]) == 16)
    print(solution([1, 2, 3, 4, 5]) == 8)

    # 边界测试：数组长度为2
    print(solution([1, 2]) == 2)

    # 边界测试：所有元素相同
    print(solution([5, 5, 5, 5]) == 5 + 5 + 0 - 1 = 9)

四，总结

通过将问题转化为动态规划的形式，我们实现了：

1. 线性时间复杂度：一次遍历解决问题
2. 常数空间复杂度：无需额外存储空间
3. 普适性：适用于所有整数数组

这种解法不仅高效，还展现了动态规划在算法中的巧妙应用。当遇到"需要在数组中找到最优组合"类问题时，动态规划往往是解决问题的关键钥匙。