Return the maximum product of nums after at most k operations. Since the answer may be very large, return it modulo 109 + 7.

Example 1:

Input: nums = [0,4], k = 5
Output: 20
Explanation: Increment the first number 5 times.
Now nums = [5, 4], with a product of 5 * 4 = 20.
It can be shown that 20 is maximum product possible, so we return 20.
Note that there may be other ways to increment nums to have the maximum product.

Example 2:

Input: nums = [6,3,3,2], k = 2
Output: 216
Explanation: Increment the second number 1 time and increment the fourth number 1 time.
Now nums = [6, 4, 3, 3], with a product of 6 * 4 * 3 * 3 = 216.
It can be shown that 216 is maximum product possible, so we return 216.
Note that there may be other ways to increment nums to have the maximum product.

Constraints:

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

Solution: priority queue

Always increment the smallest number. Proof?

Time complexity: O(klogn + nlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumProduct(vector<int>& nums, int k) {
    constexpr int kMod = 1e9 + 7;
    priority_queue<int, vector<int>, greater<int>> q(begin(nums), end(nums));
    while (k--) {
      const int n = q.top(); 
      q.pop();
      q.push(n + 1);
    }
    long long ans = 1;
    while (!q.empty()) {
      ans *= q.top(); q.pop();
      ans %= kMod;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2233. Maximum Product After K Increments appeared first on Huahua's Tech Road.

Given an array nums of n integers where n > 1,  return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

Example:

Input:  [1,2,3,4] Output: [24,12,8,6]

Note: Please solve it without division and in O(n).

Follow up:
Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.)

Solution: DP

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 36 ms
class Solution {
public:
  vector<int> productExceptSelf(vector<int>& nums) {
    const int n = nums.size();
    vector<int> l(n, 1); // l[i] = prod(nums[0] ~ nums[i - 1])
    vector<int> r(n, 1); // l[i] = prod(nums[i + 1] ~ nums[n - 1])
    vector<int> ans(n);    
    
    for (int i = 1; i < n; ++i)
      l[i] = l[i - 1] * nums[i - 1];
    
    for (int i = n - 2; i >= 0; --i)
      r[i] = r[i + 1] * nums[i + 1];
        
    for (int i = 0; i < n; ++i)
      ans[i] = l[i] * r[i];
    
    return ans;
  }
};

// Author: Huahua
// Running time: 32 ms
class Solution {
public:
  vector<int> productExceptSelf(vector<int>& nums) {
    const int n = nums.size();
    int l = 1; // l = prod(nums[0] ~ nums[i - 1])
    int r = 1; // r = prod(nums[i + 1] ~ nums[n - 1])
    vector<int> ans(n, 1);
        
    for (int i = 0; i < n; ++i) {
      ans[i] *= l;
      ans[n - i - 1] *= r;
      l *= nums[i];
      r *= nums[n - i - 1];
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 238. Product of Array Except Self appeared first on Huahua's Tech Road.