2873. Maximum Value of an Ordered Triplet I

You are given a 0-indexed integer array nums.

Return the maximum value over all triplets of indices (i, j, k) such that i < j < k. If all such triplets have a negative value, return 0.

The value of a triplet of indices (i, j, k) is equal to (nums[i] - nums[j]) * nums[k].

Example 1:

Input: nums = [12,6,1,2,7]
Output: 77
Explanation: The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) * nums[4] = 77.
It can be shown that there are no ordered triplets of indices with a value greater than 77.

Example 2:

Input: nums = [1,10,3,4,19]
Output: 133
Explanation: The value of the triplet (1, 2, 4) is (nums[1] - nums[2]) * nums[4] = 133.
It can be shown that there are no ordered triplets of indices with a value greater than 133.

Example 3:

Input: nums = [1,2,3]
Output: 0
Explanation: The only ordered triplet of indices (0, 1, 2) has a negative value of (nums[0] - nums[1]) * nums[2] = -3. Hence, the answer would be 0.

Constraints:

• 3 <= nums.length <= 100
• 1 <= nums[i] <= 106

Approach 01:

#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    long long maximumTripletValue(vector<int>& nums) {
        int maxPrefix = nums[0];  
        int maxDifference = INT_MIN;  
        long long maxTripletProduct = 0;  

        for (int j = 1; j < nums.size() - 1; ++j) {
            maxDifference = max(maxDifference, maxPrefix - nums[j]);  
            maxPrefix = max(maxPrefix, nums[j]);  
            maxTripletProduct = max(maxTripletProduct, static_cast<long long>(maxDifference) * nums[j + 1]);  
        }

        return maxTripletProduct;
    }
};

from typing import List

class Solution:
    def maximumTripletValue(self, nums: List[int]) -> int:

        maxNumI = nums[0]  
        maxDiff = float('-inf')  
        maxTripletValue = 0  

        for j in range(1, len(nums) - 1):
            maxDiff = max(maxDiff, maxNumI - nums[j])  
            maxNumI = max(maxNumI, nums[j])  
            maxTripletValue = max(maxTripletValue, maxDiff * nums[j + 1])  

        return maxTripletValue

Time Complexity:

• Single Pass Through Array:

  The algorithm iterates through the array once using a single loop, making it \( O(N) \), where \( N \) is the number of elements in nums.

• Constant Time Operations:

  All operations inside the loop (calculating differences, updating max values, and computing triplet product) take \( O(1) \) time.

• Total Time Complexity:

  The overall time complexity is \( O(N) \).

Space Complexity:

• Auxiliary Variables:

  The algorithm uses a constant number of extra variables (maxPrefix, maxDifference, and maxTripletProduct), all requiring \( O(1) \) space.

• Input Storage:

  The input array nums is given and not modified, so no additional space is used beyond input.

• Total Space Complexity:

  The overall space complexity is \( O(1) \).