# Minimize cost required to make all array elements greater than or equal to zero

• Last Updated : 15 Nov, 2021

Given an array arr[] consisting of N integers and an integer X, the task is to find the minimum cost required to make all array elements greater than or equal to 0 by performing the following operations any number of times:

• Increase any array element by 1. Cost = 1.
• Increase all array elements by 1. Cost = X.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {-1, -3, 3, 4, 5}, X = 2
Output: 4
Explanation:
Increment arr by 1. The array arr[] modifies to {0, -3, 3, 4, 5}. Cost = 1.
Increment arr by 1 thrice. The array arr[] modifies to {0, 0, 3, 4, 5}. Therefore, Cost = 4.
Hence, the total cost required is 4.

Input: arr[] = {-3, -2, -1, -5, 7}, X = 2
Output: 8

Approach: The idea is to use Greedy Approach to solve the problem. Follow the steps below to solve the problem:

• Sort the array arr[] in ascending order.
• Initialize an auxiliary vector, say list, to store the negative array elements.
• Initialize a variable, cost = 0, to store the cost required to make the current array element  0 and another variable, min_cost = INT_MAX, to store the final minimum cost to make all array elements >= 0.
• Traverse the array arr[] and try to convert all the array elements in the list >= 0 by applying the suitable operations and update min_cost accordingly.
• Print the value of min_cost as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum``// cost to make all array elements``// greater than or equal to 0``void` `minCost(``int` `arr[], ``int` `N, ``int` `X)``{``    ``// Sort the array in``    ``// ascending order``    ``sort(arr, arr + N);` `    ``int` `sum = 0;` `    ``// Stores the cost to make``    ``// current array element >= 0``    ``int` `cost = 0;` `    ``// Stores the cost to make``    ``// all array elements >= 0``    ``int` `min_cost = INT_MAX;` `    ``// Traverse the array and insert all the``    ``// elements which are < 0``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If current array element``        ``// is negative``        ``if` `(arr[i] < 0) {` `            ``// Cost to make all array``            ``// elements >= 0``            ``cost = ``abs``(arr[i]) * X``                   ``+ (sum - ``abs``(arr[i]) * i);``            ``sum += ``abs``(arr[i]);` `            ``// Update curr if ans is minimum``            ``min_cost = min(min_cost, cost);``        ``}``    ``}` `    ``// Print the minimum cost``    ``cout << min_cost;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { -1, -3, -2, 4, -1 };` `    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Given value of X``    ``int` `X = 2;` `    ``// Function call to find minimum``    ``// cost to make all array elements >= 0``    ``minCost(arr, N, X);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;``public` `class` `GFG``{   ` `  ``// Function to find the minimum``  ``// cost to make all array elements``  ``// greater than or equal to 0``  ``static` `void` `minCost(``int` `arr[], ``int` `N, ``int` `X)``  ``{` `    ``// Sort the array in``    ``// ascending order``    ``Arrays.sort(arr) ;` `    ``int` `sum = ``0``;` `    ``// Stores the cost to make``    ``// current array element >= 0``    ``int` `cost = ``0``;` `    ``int` `INT_MAX = Integer.MAX_VALUE;` `    ``// Stores the cost to make``    ``// all array elements >= 0``    ``int` `min_cost = INT_MAX;` `    ``// Traverse the array and insert all the``    ``// elements which are < 0``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// If current array element``      ``// is negative``      ``if` `(arr[i] < ``0``) {` `        ``// Cost to make all array``        ``// elements >= 0``        ``cost = Math.abs(arr[i]) * X``          ``+ (sum - Math.abs(arr[i]) * i);``        ``sum += Math.abs(arr[i]);` `        ``// Update curr if ans is minimum``        ``min_cost = Math.min(min_cost, cost);``      ``}``    ``}` `    ``// Print the minimum cost``    ``System.out.print(min_cost);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// Given array``    ``int` `arr[] = { -``1``, -``3``, -``2``, ``4``, -``1` `};` `    ``// Size of the array``    ``int` `N = arr.length;` `    ``// Given value of X``    ``int` `X = ``2``;` `    ``// Function call to find minimum``    ``// cost to make all array elements >= 0``    ``minCost(arr, N, X);` `  ``}` `}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to find the minimum``# cost to make all array of elements``# greater than or equal to 0``def` `mincost(arr, N, X):``  ` `    ``# sort the array in``    ``# ascending order``    ``arr.sort()``    ``sum` `=` `0``    ` `    ``# stores the count to make``    ``# current array element >=0``    ``cost ``=` `0``    ` `    ``# stores the cost to make``    ``# all array elements >=0``    ``min_cost ``=` `sys.maxsize``    ` `    ``# Traverse the array and insert all the``    ``# elements which are <=0``    ``for` `i ``in` `range``(``0``, N):``      ` `        ``# if current array element``        ``# is negative``        ``if` `(arr[i] < ``0``):``          ` `            ``# cost to make all array``            ``# elements >=0``            ``cost ``=` `abs``(arr[i]) ``*` `x ``+` `(``sum` `-` `abs``(arr[i]) ``*` `i)``            ``sum` `+``=` `abs``(arr[i])``            ` `            ``# update curr if ans is minimum``            ``min_cost ``=` `min``(min_cost,cost)``    ` `    ``# return minimum cost``    ``return` `min_cost` `# Driver code``arr ``=` `[``-``1``, ``-``3``, ``-``2``, ``4``, ``-``1``]` `# size of the array``N ``=` `len``(arr)` `# Given value of x``x ``=` `2` `# Function call to find minimum``# cost to make all array elements >=0``print``(mincost(arr, N, x))` `# This code is contributed by Virusbuddah`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `// Function to find the minimum``// cost to make all array elements``// greater than or equal to 0``static` `void` `minCost(``int``[] arr, ``int` `N, ``int` `X)``{` `    ``// Sort the array in``    ``// ascending order``    ``Array.Sort(arr) ;``    ` `    ``int` `sum = 0;``    ` `    ``// Stores the cost to make``    ``// current array element >= 0``    ``int` `cost = 0;``    ` `    ``//int INT_MAX = Int32.MaxValue;``    ` `    ``// Stores the cost to make``    ``// all array elements >= 0``    ``int` `min_cost = Int32.MaxValue;``    ` `    ``// Traverse the array and insert all the``    ``// elements which are < 0``    ``for``(``int` `i = 0; i < N; i++)``    ``{``    ` `        ``// If current array element``        ``// is negative``        ``if` `(arr[i] < 0)``        ``{``        ` `            ``// Cost to make all array``            ``// elements >= 0``            ``cost = Math.Abs(arr[i]) * X + ``            ``(sum - Math.Abs(arr[i]) * i);``            ``sum += Math.Abs(arr[i]);``            ` `            ``// Update curr if ans is minimum``            ``min_cost = Math.Min(min_cost, cost);``        ``}``    ``}``    ` `    ``// Print the minimum cost``    ``Console.Write(min_cost);``}` `// Driver Code``static` `public` `void` `Main ()``{``    ` `    ``// Given array``    ``int``[] arr = { -1, -3, -2, 4, -1 };` `    ``// Size of the array``    ``int` `N = arr.Length;` `    ``// Given value of X``    ``int` `X = 2;` `    ``// Function call to find minimum``    ``// cost to make all array elements >= 0``    ``minCost(arr, N, X);``}``}` `// This code is contributed by susmitakundugoaldanga`

## Javascript

 ``
Output:
`5`

Time Complexity: O(N * logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up