Easy

题目描述

给你一个整数数组 nums。考虑以下操作：

  • 删除数组的前两个元素，并将这两个元素的和定义为操作的分数。

你可以执行此操作，直到 nums 包含少于两个元素。此外，所有操作必须获得相同的分数。

返回你可以执行的最大操作数。

示例 1：

输入：nums = [3,2,1,4,5]
输出：2
解释：
- 我们可以执行第一次操作，分数为 3 + 2 = 5。操作后，nums = [1,4,5]。
- 我们可以执行第二次操作，分数为 4 + 1 = 5，与前一次操作相同。操作后，nums = [5]。
- 由于元素少于两个，我们无法执行更多操作。

示例 2：

输入：nums = [1,5,3,3,4,1,3,2,2,3]
输出：2
解释：
- 我们可以执行第一次操作，分数为 1 + 5 = 6。操作后，nums = [3,3,4,1,3,2,2,3]。
- 我们可以执行第二次操作，分数为 3 + 3 = 6，与前一次操作相同。操作后，nums = [4,1,3,2,2,3]。
- 我们无法执行下一次操作，因为分数为 4 + 1 = 5，与前面的分数不同。

示例 3：

输入：nums = [5,3]
输出：1

提示：

  • 2 <= nums.length <= 100
  • 1 <= nums[i] <= 1000

解题思路

解题思路

这是一道模拟题，关键在于理解题目要求：每次操作都必须删除数组的前两个元素，且所有操作的分数（前两个元素之和）必须相同。

思路分析：

  1. 确定目标分数：第一次操作的分数就是我们的目标分数，即 nums[0] + nums[1]
  2. 逐步验证：从数组开头开始，每次取前两个元素计算分数，如果等于目标分数则继续，否则停止
  3. 统计操作次数：记录成功执行的操作次数

算法步骤：

  • 计算目标分数：target = nums[0] + nums[1]
  • 使用指针 i 从位置 0 开始，每次检查 nums[i] + nums[i+1] 是否等于目标分数
  • 如果相等，操作次数加1，指针向后移动2位
  • 如果不等或数组剩余元素不足2个，停止操作

这个解法的时间复杂度是 O(n)，空间复杂度是 O(1)，非常高效。

代码实现

class Solution {
public:
    int maxOperations(vector<int>& nums) {
        int target = nums[0] + nums[1];
        int operations = 0;
        
        for (int i = 0; i + 1 < nums.size(); i += 2) {
            if (nums[i] + nums[i + 1] == target) {
                operations++;
            } else {
                break;
            }
        }
        
        return operations;
    }
};

class Solution:
    def maxOperations(self, nums: List[int]) -> int:
        target = nums[0] + nums[1]
        operations = 0
        i = 0
        
        while i + 1 < len(nums):
            if nums[i] + nums[i + 1] == target:
                operations += 1
                i += 2
            else:
                break
        
        return operations

public class Solution {
    public int MaxOperations(int[] nums) {
        int target = nums[0] + nums[1];
        int operations = 0;
        
        for (int i = 0; i + 1 < nums.Length; i += 2) {
            if (nums[i] + nums[i + 1] == target) {
                operations++;
            } else {
                break;
            }
        }
        
        return operations;
    }
}

var maxOperations = function(nums) {
    const target = nums[0] + nums[1];
    let operations = 0;
    
    for (let i = 0; i + 1 < nums.length; i += 2) {
        if (nums[i] + nums[i + 1]
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度分析
时间复杂度O(n)，其中 n 是数组长度。最坏情况下需要遍历整个数组
空间复杂度O(1)，只使用常数额外空间