leetcode1014. 最佳观光组合（Python3）

leetcode1014. 最佳观光组合

给定正整数数组 A，A[i] 表示第 i 个观光景点的评分，并且两个景点 i 和 j 之间的距离为 j - i。

一对景点（i < j）组成的观光组合的得分为（A[i] + A[j] + i - j）：景点的评分之和减去它们两者之间的距离。

返回一对观光景点能取得的最高分。

示例：

输入：[8,1,5,2,6]
输出：11
解释：i = 0, j = 2, A[i] + A[j] + i - j = 8 + 5 + 0 - 2 = 11

提示：

1. 2 <= A.length <= 50000
2. 1 <= A[i] <= 1000

---

方法一：动态规划

思路：

我们首先使用动态规划的方法来解决。

dp[i]表示以A[i]为第二个观光点取得的最大的分数时，对应的第一个观光点的下标。

​ 那么状态转移方程为：

​ if A[i] + A[dp[i-1]] - (i-dp[i-1]) > A[i]+A[i-1]-1:

​ dp[i] = dp[i-1]

​ else:

​ dp[i] = i-1

A[i] + A[dp[i-1]] - (i-dp[i-1])表示此时第二个点为i，第一个点为dp[i-1]，此时的分数。因为当i-1为第二个点时，它可以选择的第一个点为[0,i-2]，然后选出可以取得最大值的为dp[i-1]。

当第二个点为i时，如果它在[0,i-2]中选第一个点，那么肯定也是选择dp[i-1]作为第一个点取得分数最大。它还可以选择i-1作为第一个点，那么此时分数为A[i]+A[i-1]-1，因此只要比较这两个分数之间的大小，就可以完成dp的更新，值得注意的是，当两个分数相等时，我们使用后者更新，因为后者情况下，两个点的距离较短。

我们遍历过程中，不断更新最大分数，最后返回即可。

复杂度分析：

• 只遍历了一次，时间复杂度为O(N)
• 使用了额外的dp数组，空间复杂度为O(N)，不过由于dp[i]更新只与dp[i-1]有关，可以使用变量来保存，将复杂度降到O(1)

代码：

class Solution:
    def maxScoreSightseeingPair(self, A: List[int]) -> int:
        '''
        dp[i]表示以A[i]为第二个观光点取得的最大的分，对应的第一个观光点的坐标
        那么状态转移方程为：
        if A[i] + A[dp[i-1]] - (i-dp[i-1]) > A[i]+A[i-1]-1:
            dp[i] = dp[i-1]
        else:
            dp[i] = i-1
        ''' 
        n = len(A)
        dp = [0 for _ in range(n)]
        #初始化答案
        ans = A[0] + A[1] - 1
        #开始遍历
        for i in range(2,n):
            temp1 = A[i] + A[dp[i-1]]-(i-dp[i-1])
            temp2 = A[i]+A[i-1]-1
            #更新答案及dp数组
            if temp1 > temp2:
                ans = max(ans,temp1)
                dp[i] = dp[i-1]
            else:
                dp[i] = i-1
                ans = max(ans,temp2)
        return ans

结果：

方法二：枚举

思路：

我们首先看分数的式子：（A[i] + i + A[j] - j），把它分成两部分，一部分只与i有关，一部分只与j有关。

我们从头遍历j，遍历的同时，也计算A[j]+j来不断更新A[i] + i的最大值，计算此时j位置的最大分数，使用ans来维护所有j位置的最大分数。最后返回ans即可。

注意i和j不能相等，因此遍历j的时候，要先计算当前j的最大分数，然后再通过j来计算计算A[j]+j来更新A[i] + i的最大值。

复杂度分析：

• 只遍历了一次，时间复杂度为O(N)
• 只使用了常数空间，空间复杂度为O(1)

代码：

class Solution:
    def maxScoreSightseeingPair(self, A: List[int]) -> int:
        ans = 0
        n = len(A)
        #max_i表示j之前最大的A[i]+i
        max_i = A[0]
        for j in range(1,n):
            #更新最大的分数
            ans = max(ans,max_i+A[j]-j)
            #更新max_i
            max_i = max(max_i,A[j]+j)
        return ans

结果：