Welcome to Subscribe On Youtube

2873. Maximum Value of an Ordered Triplet I

Description

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

Solutions

Solution 1: Maintain Maximum Prefix Value and Maximum Difference

We can use two variables $mx$ and $mx_diff$ to maintain the maximum prefix value and maximum difference, respectively. When traversing the array, we update these two variables, and the answer is the maximum value of all $mx_diff \times nums[i]$.

The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.

  • class Solution {
        public long maximumTripletValue(int[] nums) {
            long max, maxDiff, ans;
            max = 0;
            maxDiff = 0;
            ans = 0;
            for (int num : nums) {
                ans = Math.max(ans, num * maxDiff);
                max = Math.max(max, num);
                maxDiff = Math.max(maxDiff, max - num);
            }
            return ans;
        }
    }
    
  • class Solution {
    public:
        long long maximumTripletValue(vector<int>& nums) {
            long long ans = 0;
            int mx = 0, mx_diff = 0;
            for (int num : nums) {
                ans = max(ans, 1LL * mx_diff * num);
                mx = max(mx, num);
                mx_diff = max(mx_diff, mx - num);
            }
            return ans;
        }
    };
    
  • class Solution:
        def maximumTripletValue(self, nums: List[int]) -> int:
            ans = mx = mx_diff = 0
            for num in nums:
                ans = max(ans, mx_diff * num)
                mx = max(mx, num)
                mx_diff = max(mx_diff, mx - num)
            return ans
    
    
  • func maximumTripletValue(nums []int) int64 {
    	ans, mx, mx_diff := 0, 0, 0
    	for _, num := range nums {
    		ans = max(ans, mx_diff*num)
    		mx = max(mx, num)
    		mx_diff = max(mx_diff, mx-num)
    	}
    	return int64(ans)
    }
    
    func max(a, b int) int {
    	if a > b {
    		return a
    	}
    	return b
    }
    
  • function maximumTripletValue(nums: number[]): number {
        let [ans, mx, mx_diff] = [0, 0, 0];
        for (const num of nums) {
            ans = Math.max(ans, mx_diff * num);
            mx = Math.max(mx, num);
            mx_diff = Math.max(mx_diff, mx - num);
        }
        return ans;
    }
    
    

All Problems

All Solutions