Leetcode 2023-08-27 题目分享

Leetcode

2835. 使子序列的和等于目标的最少操作次数 - 力扣（LeetCode）

给你一个下标从 0 开始的数组 nums ，它包含非负整数，且全部为 2 的幂，同时给你一个整数 target 。

一次操作中，你必须对数组做以下修改：

选择数组中一个元素 nums[i] ，满足 nums[i] > 1 。

将 nums[i] 从数组中删除。

在 nums 的末尾添加两个数，值都为 nums[i] / 2 。

你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。

数组中一个 子序列 是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。

示例 1：
1
2
3
4
5
输入：nums = [1,2,8], target = 7
输出：1
解释：第一次操作中，我们选择元素 nums[2] 。数组变为 nums = [1,2,4,4] 。
这时候，nums 包含子序列 [1,2,4] ，和为 7 。
无法通过更少的操作得到和为 7 的子序列。
示例 2：
1
2
3
4
5
6
输入：nums = [1,32,1,2], target = 12
输出：2
解释：第一次操作中，我们选择元素 nums[1] 。数组变为 nums = [1,1,2,16,16] 。
第二次操作中，我们选择元素 nums[3] 。数组变为 nums = [1,1,2,16,8,8] 。
这时候，nums 包含子序列 [1,1,2,8] ，和为 12 。
无法通过更少的操作得到和为 12 的子序列。
示例 3：
1
2
3
输入：nums = [1,32,1], target = 35
输出：-1
解释：无法得到和为 35 的子序列。
提示：

1 <= nums.length <= 1000

1 <= nums[i] <= 2^30

nums 只包含非负整数，且均为 2 的幂。

1 <= target < 2^31

思路

数组中每个数最后都可以分成若干个 1 ，因此如果数组元素和小于 target 返回-1，否则一定有解。然后将 target 分解到每一位，从低位到高位依次遍历，遍历过程中一同计算未被使用的数值和 pre。

如果 target 的第 i 位是 0 ，跳过。
如果 target 的第 i 位是 1 ：
1. pre 大于等于2ⁱ，说明这一位代表的数值可以被之前遍历到的数相加得到。（因为每个数最后都可以变为 1，所以只要大于等于它，就一定可以表示出）
2. 反之说明需要往前找到 target 第一个 1 的位置，将它不断一分为二到当前位，同时更新 ans。

代码

int minOperations(vector<int>& nums, int target) {
    int n = nums.size();
    unordered_map<int, int> mp;
    for (int i = 0;i <= 30;i++) mp[(1<<i)] = i;
    // cnt[i]表示nums中的数等于1<<i的数量
    vector<int> cnt(31, 0);
    for (int i = 0;i < n;i++) cnt[mp[nums[i]]]++;
    int ans = 0;
    long long pre = 0;
    // 从低到高遍历每一位
    for (int i = 0;i <= 30;i++){
        pre += 1L*cnt[i]*(1<<i);
        int x = (target >> i & 1), val = x*(1<<i);
        // 小于pre 直接可以凑出 1<<i 了，减去被使用的值
        if (val <= pre){
            pre -= val;
            continue;
        }
      	// 向前找到第一个1
        int f = 0, j = i+1;
        for (;j <= 30 && f == 0;j++){
            if (cnt[j] != 0){
                f = 1;
                break;
            }
            cnt[j]++;
            ans++;
        }
        if (f == 0) return -1;
        cnt[j]--;
        ans++;
        pre += (1<<i);
    }
    return ans;
}

复杂度分析

时间复杂度: O(log n) 。
空间复杂度: O(log n) 。