Difference Between Maximum And Minimum Price Sum - Leetcode Solution

Problem Statement: Given an array of n integers, find the maximum and minimum possible sum of two distinct elements from the array.

Example: Input: [1, 2, 3, 4, 5] Output: [6, 9] Explanation: The maximum sum is obtained by adding 4 and 5, and the minimum sum is obtained by adding 1 and 2.

Solution: One approach to solve this problem is to keep track of the maximum and minimum element in the array and find the maximum and minimum possible sum using these two elements.

Algorithm:

1. Initialize two variables max and min to the first element of the array.
2. Traverse the array from the second element.
3. If the current element is greater than max, update max.
4. If the current element is smaller than min, update min.
5. Once the traversal is completed, the maximum sum can be obtained by adding max and the second highest element in the array, and the minimum sum can be obtained by adding min and the second smallest element in the array.
6. Return the maximum and minimum sum as an array.

Code:

public int[] maxAndMinSum(int[] nums) {
    int n = nums.length;
    int max = nums[0], min = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] > max) {
            max = nums[i];
        }
        if (nums[i] < min) {
            min = nums[i];
        }
    }
    int maxSum = max + secondHighest(nums, max);
    int minSum = min + secondSmallest(nums, min);
    return new int[]{maxSum, minSum};
}

private int secondHighest(int[] nums, int max) {
    int second = Integer.MIN_VALUE;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != max) {
            second = Math.max(second, nums[i]);
        }
    }
    return second;
}

private int secondSmallest(int[] nums, int min) {
    int second = Integer.MAX_VALUE;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != min) {
            second = Math.min(second, nums[i]);
        }
    }
    return second;
}

Time Complexity: O(n) Space Complexity: O(1)

Explanation: The above code first initializes two variables max and min to the first element of the array. Then, the array is traversed from the second element and if the current element is greater than the previous max, the max value is updated. Similarly, if the current element is smaller than the previous min value, it is updated. After traversing the array, the maximum sum is calculated by adding max and the second highest element in the array. The second highest element can be obtained by iterating through the array again and finding the maximum element that is not equal to max. Similarly, the minimum sum is calculated by adding min and the second smallest element in the array.

In conclusion, this problem can be solved by finding the maximum and minimum element in the array and adding them to the second highest and second smallest elements, respectively. The time complexity of this approach is O(n) as we only need to iterate through the array twice and the space complexity is constant as we only need a few variables to store the intermediate results.

1