Skip to content

Latest commit

 

History

History
191 lines (152 loc) · 4.96 KB

README.md

File metadata and controls

191 lines (152 loc) · 4.96 KB
comments difficulty edit_url tags
true
中等
贪心
数组
动态规划

2892. 将相邻元素相乘后得到最小化数组 🔒

English Version

题目描述

给定一个整数数组 nums 和一个整数 k，你可以对数组执行以下操作任意次数：

  • 选择数组中的两个 相邻 元素，例如 x 和 y，使得 x * y <= k ，并用一个值为 x * y 的 单个元素 替换它们（例如，在一次操作中，数组 [1, 2, 2, 3]，其中 k = 5 可以变为 [1, 4, 3] 或 [2, 2, 3]，但不能变为 [1, 2, 6]）。

返回 经过任意次数的操作后， nums 的 最小 可能长度。

 

示例 1：

输入：nums = [2,3,3,7,3,5], k = 20
输出：3
解释：我们执行以下操作：
1. [2,3,3,7,3,5] -> [6,3,7,3,5]
2. [6,3,7,3,5] -> [18,7,3,5]
3. [18,7,3,5] -> [18,7,15]
可以证明，在执行给定操作后，最小可能长度为3.

示例 2：

输入：nums = [3,3,3,3], k = 6
输出：4
解释：由于每两个相邻元素的乘积都大于 6，所以无法执行任何操作。因此，答案为 4。

 

约束条件：

  • 1 <= nums.length <= 105
  • 0 <= nums[i] <= 109
  • 1 <= k <= 109

解法

方法一：贪心

我们用一个变量 $ans$ 记录当前数组的长度，用一个变量 $y$ 记录当前数组的乘积，初始时 $ans = 1$, $y = nums[0]$。

我们从数组的第二个元素开始遍历，设当前元素为 $x$：

  • 如果 $x = 0$，那么整个数组的乘积为 $0 \le k$，因此答案数组的最小长度为 $1$，直接返回即可。
  • 如果 $x \times y \le k$，那么我们可以将 $x$ 与 $y$ 合并，即 $y = x \times y$。
  • 如果 $x \times y \gt k$，那么我们无法将 $x$ 与 $y$ 合并，因此我们需要将 $x$ 单独作为一个元素，即 $ans = ans + 1$，并且 $y = x$。

最终答案即为 $ans$。

时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。

Python3

class Solution:
    def minArrayLength(self, nums: List[int], k: int) -> int:
        ans, y = 1, nums[0]
        for x in nums[1:]:
            if x == 0:
                return 1
            if x * y <= k:
                y *= x
            else:
                y = x
                ans += 1
        return ans

Java

class Solution {
    public int minArrayLength(int[] nums, int k) {
        int ans = 1;
        long y = nums[0];
        for (int i = 1; i < nums.length; ++i) {
            int x = nums[i];
            if (x == 0) {
                return 1;
            }
            if (x * y <= k) {
                y *= x;
            } else {
                y = x;
                ++ans;
            }
        }
        return ans;
    }
}

C++

class Solution {
public:
    int minArrayLength(vector<int>& nums, int k) {
        int ans = 1;
        long long y = nums[0];
        for (int i = 1; i < nums.size(); ++i) {
            int x = nums[i];
            if (x == 0) {
                return 1;
            }
            if (x * y <= k) {
                y *= x;
            } else {
                y = x;
                ++ans;
            }
        }
        return ans;
    }
};

Go

func minArrayLength(nums []int, k int) int {
	ans, y := 1, nums[0]
	for _, x := range nums[1:] {
		if x == 0 {
			return 1
		}
		if x*y <= k {
			y *= x
		} else {
			y = x
			ans++
		}
	}
	return ans
}

TypeScript

function minArrayLength(nums: number[], k: number): number {
    let [ans, y] = [1, nums[0]];
    for (const x of nums.slice(1)) {
        if (x === 0) {
            return 1;
        }
        if (x * y <= k) {
            y *= x;
        } else {
            y = x;
            ++ans;
        }
    }
    return ans;
}