Minimum possible sum of array elements after performing the given operation
Last Updated :
29 May, 2022
Given an array arr[] of size N and a number X. If any sub array of the array(possibly empty) arr[i], arr[i+1], … can be replaced with arr[i]/x, arr[i+1]/x, …. The task is to find the minimum possible sum of the array which can be obtained.
Note: The given operation can only be performed once.
Examples:
Input: N = 3, X = 2, arr[] = {1, -2, 3}
Output: 0.5
Explanation:
On selecting subarray {3} and replacing it with {1.5}, the array becomes {1, -2, 1.5}, which gives sum = 0.5
Input: N = 5, X = 5, arr[] = {5, 5, 5, 5, 5}
Output: 5
Explanation:
On selecting subarray {5, 5, 5, 5, 5} and replacing it with {1, 1, 1, 1, 1}, the sum of the array becomes 5.
Naive Approach: A naive approach is to replace all possible positive sub-arrays with the values which we get by dividing it by X and compute the sum. But the total number of sub-arrays for any given array is (N * (N + 1))/2 where N is the size of the array. Therefore, the running time of this algorithm is O(N2).
Efficient Approach: This problem can be solved efficiently in O(N) time. On observing carefully, it can be deduced that sum can be made minimum if the subarray to be replaced satisfies the following conditions:
- The subarray should be positive.
- The sum of the subarray should be maximum.
Therefore, by reducing the subarray satisfying the above conditions, the sum can be made minimum. The subarray which satisfies the above conditions can be found by using a slight variation of Kadane’s algorithm.
After finding the maximum sum of the subarray, this can be subtracted from the sum of the array to get the minimum sum. Since the maximum sum of the sub-array is being replaced with the maximum sum / X, this factor can be added to the sum which is found. That is:
Minimum sum = (sumOfArr - subSum) + (subSum/ X)
where sumOfArr is the sum of all elements of the array
and subSum is the maximum sum of the subarray.
Below is the implementation of the above approach:
CPP
#include <bits/stdc++.h>
using namespace std;
double maxSubArraySum(double a[], int size)
{
double max_so_far = INT_MIN,
max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
double minPossibleSum(double a[], int n, double x)
{
double mxSum = maxSubArraySum(a, n);
double sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
sum = sum - mxSum + mxSum / x;
cout << setprecision(2) << sum << endl;
}
int main()
{
int N = 3;
double X = 2;
double A[N] = { 1, -2, 3 };
minPossibleSum(A, N, X);
}
|
Java
class GFG{
static double maxSubArraySum(double a[], int size)
{
double max_so_far = Integer.MIN_VALUE,
max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
static void minPossibleSum(double a[], int n, double x)
{
double mxSum = maxSubArraySum(a, n);
double sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
sum = sum - mxSum + mxSum / x;
System.out.print(sum +"\n");
}
public static void main(String[] args)
{
int N = 3;
double X = 2;
double A[] = { 1, -2, 3 };
minPossibleSum(A, N, X);
}
}
|
Python3
def maxSubArraySum(a, size):
max_so_far = -10**9
max_ending_here = 0
for i in range(size):
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
def minPossibleSum(a,n, x):
mxSum = maxSubArraySum(a, n)
sum = 0
for i in range(n):
sum += a[i]
sum = sum - mxSum + mxSum / x
print(round(sum,2))
if __name__ == '__main__':
N = 3
X = 2
A=[1, -2, 3]
minPossibleSum(A, N, X)
|
C#
using System;
class GFG{
static double maxSubArraySum(double[] a, int size)
{
double max_so_far = Int32.MinValue,
max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
static void minPossibleSum(double[] a, int n, double x)
{
double mxSum = maxSubArraySum(a, n);
double sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
sum = sum - mxSum + mxSum / x;
Console.Write(sum +"\n");
}
public static void Main()
{
int N = 3;
double X = 2;
double[] A = { 1, -2, 3 };
minPossibleSum(A, N, X);
}
}
|
Javascript
<script>
function maxSubArraySum( a, size)
{
var max_so_far = -1000000000,
max_ending_here = 0;
for (var i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
function minPossibleSum(a, n, x)
{
var mxSum = maxSubArraySum(a, n);
var sum = 0;
for (var i = 0; i < n; i++) {
sum += a[i];
}
sum = sum - mxSum + mxSum / x;
document.write(sum);
}
var N = 3;
var X = 2;
var A = [ 1, -2, 3 ];
minPossibleSum(A, N, X);
</script>
|
Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(1), as we are not using any extra space.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...