# Solution For Minimum Score By Changing Two Elements

Problem Statement:

Given an integer array nums, find the minimum sum of elements after changing two elements at most. Each element can be changed to any value.

Example 1:

Input: nums = [1,2,3,4,5] Output: 10
Explanation: Change nums and nums to 1 and 2 respectively.
Minimum sum is 1 + 2 + 1 + 2 + 5 = 11.

Solution:

To solve this problem, we need to find the two smallest elements in the array and replace them with any value to minimize the sum. There can be two cases:

Case 1: If there are at least two elements in the array.

In this case, we can find the first minimum element and second minimum element in the array. Then, we replace these two elements with any value and calculate the minimum sum of the updated array. Since we replace the smallest elements, the sum is minimized.

Example:

nums = [4,2,3,1,5]

First minimum = 1
Second minimum = 2

Replace 1 with 4 and 2 with 3

Updated array: [4,3,3,4,5]

Minimum sum = 4+3+3+4+5 = 19

Case 2: If there is only one element in the array.

In this case, the minimum sum is simply the value of the element.

Pseudo code:

1. Initialize two variables min1 and min2 to maximum possible value.
2. Traverse the array and for each element:
a. If the element is smaller than min1, set min2 = min1 and min1 = element
b. Else if the element is smaller than min2, set min2 = element
3. If length of array is less than 2, return the only element.
4. Else, return the sum of all the elements in the array except for min1 and min2, plus their replacement values.

Code in Python:

def minimumSum(nums: List[int]) -> int:
min1 = min2 = float(‘inf’) # Initializing to maximum possible value

``````for num in nums:
if num < min1:
min2 = min1
min1 = num
elif num < min2:
min2 = num

if len(nums) < 2:
return nums
else:
return sum(nums) - min1 - min2 + 2*min1 + 2*min2
``````

Time Complexity: O(n)

Space Complexity: O(1)

Explanation:

We initialize two variables to maximum possible value as we need to find the minimum elements in the array. Then, we traverse the array and find the first minimum and second minimum elements. After this, we use the above discussed cases to find the minimum sum.

In the replacement formula, we add 2min1 and 2min2 as we are replacing two elements.

## Step by Step Implementation For Minimum Score By Changing Two Elements

```class Solution {
public int minScore(int[] arr) {
int n = arr.length;
int min = arr;
int secondMin = Integer.MAX_VALUE;

for(int i = 1; i < n; i++) {
if(arr[i] < min) {
secondMin = min;
min = arr[i];
}
else if(arr[i] < secondMin && arr[i] != min) {
secondMin = arr[i];
}
}

int res = Integer.MAX_VALUE;
for(int i = 0; i < n; i++) {
int curr = arr[i];
if(curr == min) {
curr = secondMin;
}

int score = 0;
for(int j = 0; j < n; j++) {
if(i == j) continue;
if(arr[j] > curr) {
score++;
}
}
res = Math.min(res, score);
}

return res;
}
}```
```def minScore(self, A, B, C):

# A, B, and C are the respective lengths of the three sticks.

# Assume that each stick is of equal length.

# We can change the length of two sticks by 1 unit.

# The cost of doing so is the sum of the lengths of the two sticks that we are changing.

# For example, if we have stick lengths [1, 2, 3] and we want to change the lengths of sticks 2 and 3 to be 1 longer,

# the cost would be 5 (for a total length of 6).

# Return the minimum cost needed to make all the sticks the same length.

# initialize cost to be the largest possible value

cost = 99999999999999999999

# iterate through all possible pairs of sticks

for i in range(len(A)):

for j in range(i+1, len(A)):

# calculate the cost of making sticks i and j the same length

newCost = abs(A[i] - A[j]) + abs(B[i] - B[j]) + abs(C[i] - C[j])

# update cost if this cost is less than the current cost

if (newCost < cost):

cost = newCost

# return the minimum cost

return cost```
```/**
* @param {number[]} nums
* @return {number}
*/
var minScore = function(nums) {
// Initialize min to the maximum possible value
let min = Number.MAX_VALUE;

// Consider every pair of elements
for (let i = 0; i < nums.length; i++) {
for (let j = i+1; j < nums.length; j++) {

// Calculate the maximum and minimum
// of the current pair
let max = Math.max(nums[i], nums[j]);
let min = Math.min(nums[i], nums[j]);

// Update the minimum score if required
if (max - min < minScore) {
minScore = max - min;
}
}
}

return minScore;
};```
```We can solve this problem by using a greedy approach. First, we sort the array in ascending order. Then, we keep track of the minimum score by changing one element. Finally, we return the minimum of the two values.

int minimumScoreByChangingTwoElements(vector& A) { int n = A.size(); sort(A.begin(), A.end()); int min_score = A + A; for (int i = 2; i < n; i++) { int curr_score = A[i-1] + A[i]; min_score = min(min_score, curr_score); } return min_score; }```
`Given an array of integers, return the minimum score that can be achieved by changing at most two elements. The score is the sum of the absolute values of the differences between the new array and the original array. For example, given the array [8, 12, 28, 21, 14], a score of 5 can be achieved by changing the array to [8, 12, 28, 21, 13]. The score of 5 is achieved by changing the 14 to a 13, as the 13 is one less than the 14, resulting in a sum of |13-14|=1. The score of 5 is also achieved by changing the 28 to a 24, as the 24 is four less than the 28, resulting in a sum of |28-24|=4. Changing the 12 to a 9 results in a score of 6, as that's the smallest possible score. So the minimum score that can be achieved is 5.`

Scroll to Top

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]