03_Maximum_Value_of_an_Ordered_Triplet_II.cpp

// 2874. Maximum Value of an Ordered Triplet II

// 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 <= 105
// 1 <= nums[i] <= 106

class Solution
{
public:
    long long maximumTripletValue(vector<int> &nums)
    {
        long maxTriplet = 0, maxElement = 0, maxDiff = 0;
        for (long num : nums)
        {
            maxTriplet = max(maxTriplet, maxDiff * num);
            maxDiff = max(maxDiff, maxElement - num);
            maxElement = max(maxElement, num);
        }
        return maxTriplet;
    }
};

/*
This solution finds the maximum value of (nums[i] - nums[j]) * nums[k] where i < j < k.
It uses three variables:
- maxTriplet: stores the maximum triplet value found so far
- maxElement: tracks the maximum element seen so far
- maxDiff: maintains the maximum difference (nums[i] - nums[j]) encountered

For each number, it:
1. Updates maxTriplet using current maxDiff and current number
2. Updates maxDiff by comparing with (maxElement - current number)
3. Updates maxElement if current number is larger

Time Complexity: O(n) where n is length of nums array
Space Complexity: O(1) as it uses only constant extra space
*/