LeetCode:2555. 两个线段获得的最多奖品 动态规划+滑动窗口

2555. 两个线段获得的最多奖品

today 2555 两个线段获得的最多奖品

题目描述

在 X轴 上有一些奖品。给你一个整数数组prizePositions，它按照 非递减 顺序排列，其中 prizePositions[i] 是第 i 件奖品的位置。数轴上一个位置可能会有多件奖品。再给你一个整数 k 。

你可以选择两个端点为整数的线段。每个线段的长度都必须是k。你可以获得位置在任一线段上的所有奖品（包括线段的两个端点）。注意，两个线段可能会有相交。

比方说 k = 2 ，你可以选择线段 [1, 3] 和 [2, 4] ，你可以获得满足 1 <= prizePositions[i] <= 3 或者 2 <= prizePositions[i] <= 4 的所有奖品 i 。
请你返回在选择两个最优线段的前提下，可以获得的 最多 奖品数目。

示例 1：

输入：prizePositions = [1,1,2,2,3,3,5], k = 2
输出：7
解释：这个例子中，你可以选择线段 [1, 3] 和 [3, 5] ，获得 7 个奖品。

示例 2：

输入：prizePositions = [1,2,3,4], k = 0
输出：2
解释：这个例子中，一个选择是选择线段 [3, 3] 和 [4, 4] ，获得 2 个奖品。

提示:

• 1 <= prizePositions.length <= 105
• 1 <= prizePositions[i] <= 109
• 0 <= k <= 109
• prizePositions 有序非递减。

题目解析

这道题的思路是，对于每一个位置，我们都可以选择一个长度为k的线段，然后获得所有落在这个线段上的奖品。我们可以用滑动窗口来解决这个问题。

我们首先定义一个数组dp，dp[i]表示第i个位置可以获得的最大奖品数。

我们可以使用滑动窗口，使得right不断右移，直到prizePositions[right]大于prizePositions[i]+k，然后我们可以获得right-i个奖品。然后将i往右移，计算下一个位置的dp值。

最后，我们可以得到dp数组，找到以每一个字符开始时，最大的线段长度。

现在，我们需要找到，两个线段加起来的长度的最大值。

为了保证两个线段加起来长度最长，那么我们需要尽量让两条线段不重叠。

我们可以遍历dp数组，对于每一个位置i，我们可以计算位置i后续的最大奖品数maxRight[i]，表示从位置i到n的最大奖品数。

通过dp[i]+maxRight[i]，我们可以得到以位置i开始的两条线段的最长长度。

复杂度分析：

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

代码实现

Go版本：

func maximizeWin(prizePositions []int, k int) int {
    n := len(prizePositions)
    if n == 0 {
        return 0
    }
    // dp[i] 代表从位置 i 开始到最大范围内的奖品数量
    dp := make([]int, n)
    right := 0
    for i := 0; i < n; i++ {
        // 扩展 right 指针，确保 prizePositions[right] 在 [prizePositions[i], prizePositions[i] + k] 范围内
        for right < n && prizePositions[right] <= prizePositions[i] + k {
            right++
        }
        dp[i] = right - i
    }
    // 计算 maxRight 数组，maxRight[i] 表示从位置 i 到 n 的最大 dp 值
    maxRight := make([]int, n+1)
    for i := n - 1; i >= 0; i-- {
        maxRight[i] = max(maxRight[i+1], dp[i])
    }

    ans := 0

    // 遍历 dp 数组，确保两个区间不重叠
    for i := 0; i < n; i++ {
        if i + dp[i] < n { // 确保第二个区间从 i + dp[i] 之后开始
            ans = max(ans, dp[i] + maxRight[i + dp[i]])
        } else {
            ans = max(ans, dp[i])
        }
    }
    return ans
}

Python版本：

class Solution(object):
    def maximizeWin(self, prizePositions, k):
        n=len(prizePositions)
        if n==1:
            return 1
        dp=[0]*n
        right=0
        for i in range(n):
            while right<n and prizePositions[right]<=prizePositions[i]+k:
                right+=1
            dp[i]=right-i

        maxRight=[0]*(n+1)
        for j in range(n-1,-1,-1):
            maxRight[j]=max(maxRight[j+1],dp[j])

        ans=0
        for i in range(n):
            if i+dp[i]<n:
                ans=max(ans,dp[i]+maxRight[i+dp[i]])
            else:
                ans=max(ans,dp[i])

        return ans

C++版本：

class Solution {
public:
    int maximizeWin(vector<int>& prizePositions, int k) {
        int n = prizePositions.size();
        if (n == 0) {
            return 0;
        }
        
        // dp[i] 表示从位置 i 开始到最大范围内的奖品数量
        vector<int> dp(n, 0);
        int right = 0;
        
        // 计算 dp 数组
        for (int i = 0; i < n; ++i) {
            // 扩展 right 指针，确保 prizePositions[right] 在 [prizePositions[i], prizePositions[i] + k] 范围内
            while (right < n && prizePositions[right] <= prizePositions[i] + k) {
                ++right;
            }
            dp[i] = right - i;
        }
        
        // 计算 maxRight 数组，maxRight[i] 表示从位置 i 到 n 的最大 dp 值
        vector<int> maxRight(n + 1, 0);
        for (int i = n - 1; i >= 0; --i) {
            maxRight[i] = max(maxRight[i + 1], dp[i]);
        }
        
        int ans = 0;
        
        // 遍历 dp 数组，确保两个区间不重叠
        for (int i = 0; i < n; ++i) {
            if (i + dp[i] < n) { // 确保第二个区间从 i + dp[i] 之后开始
                ans = max(ans, dp[i] + maxRight[i + dp[i]]);
            } else {
                ans = max(ans, dp[i]);
            }
        }
        
        return ans;
    }
};