 GeeksforGeeks App
Open App Browser
Continue

# Minimize sum of prime numbers added to make an array non-decreasing

Given an array arr[], the task is to convert it into a non-decreasing array by adding primes to array elements such that the sum of the primes added is the minimum possible.

Examples:

Input: arr[] = {2, 1, 5, 4, 3}
Output:
Explanation:
{2, 1, 5, 4, 3} -> {2, 3, 5, 6, 6
By changing the 2nd element of array to 3(1 + 2), the 4th element of the array to 6(4 + 2) and the 5th element to 6( 3 + 3).
So, the total cost is 2 + 2 + 3 = 7

Input: arr[] = {3, 3, 3, 3}
Output: 10

Approach: The idea is to add the least prime numbers possible to the array elements to make the array non-decreasing. Below are the steps:

1. Initialize a variable to store the minimum cost, say res.
2. Generate and store all prime numbers up to 107 using the Sieve of Eratosthenes.
3. Now, traverse the array and do the following steps:
• If the current element is less than the previous element than find the smallest prime number (say closest_prime) which can be added to make the array non-decreasing.
• Update the current element arr[i] = arr[i] + closest_prime.
4. Print the final value of res obtained.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `#define MAX 10000000` `// Stores if an index is a``// prime / non-prime value``bool` `isPrime[MAX];` `// Stores the prime``vector<``int``> primes;` `// Function to generate all``// prime numbers``void` `SieveOfEratosthenes()``{``    ``memset``(isPrime, ``true``, ``sizeof``(isPrime));` `    ``for` `(``int` `p = 2; p * p <= MAX; p++) {` `        ``// If current element is prime``        ``if` `(isPrime[p] == ``true``) {` `            ``// Set all its multiples non-prime``            ``for` `(``int` `i = p * p; i <= MAX; i += p)``                ``isPrime[i] = ``false``;``        ``}``    ``}` `    ``// Store all prime numbers``    ``for` `(``int` `p = 2; p <= MAX; p++)``        ``if` `(isPrime[p])``            ``primes.push_back(p);``}` `// Function to find the closest``// prime to a particular number``int` `prime_search(vector<``int``> primes,``                 ``int` `diff)``{` `    ``// Applying binary search``    ``// on primes vector``    ``int` `low = 0;``    ``int` `high = primes.size() - 1;` `    ``int` `res;` `    ``while` `(low <= high) {``        ``int` `mid = (low + high) / 2;` `        ``// If the prime added makes``        ``// the elements equal``        ``if` `(primes[mid] == diff) {` `            ``// Return this as the``            ``// closest prime``            ``return` `primes[mid];``        ``}` `        ``// If the array remains``        ``// non-decreasing``        ``else` `if` `(primes[mid] < diff) {` `            ``// Search for a bigger``            ``// prime number``            ``low = mid + 1;``        ``}` `        ``// Otherwise``        ``else` `{` `            ``res = primes[mid];` `            ``// Check if a smaller prime  can``            ``// make array non-decreasing or not``            ``high = mid - 1;``        ``}``    ``}` `    ``// Return closest number``    ``return` `res;``}` `// Function to find the minimum cost``int` `minCost(``int` `arr[], ``int` `n)``{` `    ``// Find all primes``    ``SieveOfEratosthenes();` `    ``// Store the result``    ``int` `res = 0;` `    ``// Iterate over the array``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Current element is less``        ``// than the previous element``        ``if` `(arr[i] < arr[i - 1]) {``            ``int` `diff = arr[i - 1] - arr[i];` `            ``// Find the closest prime which``            ``// makes the array non decreasing``            ``int` `closest_prime``                ``= prime_search(primes, diff);` `            ``// Add to overall cost``            ``res += closest_prime;` `            ``// Update current element``            ``arr[i] += closest_prime;``        ``}``    ``}` `    ``// Return the minimum cost``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 1, 5, 4, 3 };``    ``int` `n = 5;` `    ``// Function Call``    ``cout << minCost(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `static` `final` `int` `MAX = ``10000000``;` `// Stores if an index is a``// prime / non-prime value``static` `boolean` `[]isPrime = ``new` `boolean``[MAX + ``1``];` `// Stores the prime``static` `Vector primes = ``new` `Vector();` `// Function to generate all``// prime numbers``static` `void` `SieveOfEratosthenes()``{``    ``Arrays.fill(isPrime, ``true``);` `    ``for``(``int` `p = ``2``; p * p <= MAX; p++)``    ``{``        ` `        ``// If current element is prime``        ``if` `(isPrime[p] == ``true``)``        ``{``            ` `            ``// Set all its multiples non-prime``            ``for``(``int` `i = p * p; i <= MAX; i += p)``                ``isPrime[i] = ``false``;``        ``}``    ``}` `    ``// Store all prime numbers``    ``for``(``int` `p = ``2``; p <= MAX; p++)``        ``if` `(isPrime[p])``            ``primes.add(p);``}` `// Function to find the closest``// prime to a particular number``static` `int` `prime_search(Vector primes,``                        ``int` `diff)``{` `    ``// Applying binary search``    ``// on primes vector``    ``int` `low = ``0``;``    ``int` `high = primes.size() - ``1``;` `    ``int` `res = -``1``;` `    ``while` `(low <= high)``    ``{``        ``int` `mid = (low + high) / ``2``;` `        ``// If the prime added makes``        ``// the elements equal``        ``if` `(primes.get(mid) == diff)``        ``{``            ` `            ``// Return this as the``            ``// closest prime``            ``return` `primes.get(mid);``        ``}` `        ``// If the array remains``        ``// non-decreasing``        ``else` `if` `(primes.get(mid) < diff)``        ``{``            ` `            ``// Search for a bigger``            ``// prime number``            ``low = mid + ``1``;``        ``}` `        ``// Otherwise``        ``else``        ``{``            ``res = primes.get(mid);` `            ``// Check if a smaller prime can``            ``// make array non-decreasing or not``            ``high = mid - ``1``;``        ``}``    ``}` `    ``// Return closest number``    ``return` `res;``}` `// Function to find the minimum cost``static` `int` `minCost(``int` `arr[], ``int` `n)``{``    ` `    ``// Find all primes``    ``SieveOfEratosthenes();` `    ``// Store the result``    ``int` `res = ``0``;` `    ``// Iterate over the array``    ``for``(``int` `i = ``1``; i < n; i++)``    ``{``        ` `        ``// Current element is less``        ``// than the previous element``        ``if` `(arr[i] < arr[i - ``1``])``        ``{``            ``int` `diff = arr[i - ``1``] - arr[i];` `            ``// Find the closest prime which``            ``// makes the array non decreasing``            ``int` `closest_prime = prime_search(primes,``                                             ``diff);` `            ``// Add to overall cost``            ``res += closest_prime;` `            ``// Update current element``            ``arr[i] += closest_prime;``        ``}``    ``}` `    ``// Return the minimum cost``    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array``    ``int` `arr[] = { ``2``, ``1``, ``5``, ``4``, ``3` `};``    ``int` `n = ``5``;` `    ``// Function call``    ``System.out.print(minCost(arr, n));``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 Program to implement``# the above approach``MAX` `=` `10000000` `# Stores if an index is a``# prime / non-prime value``isPrime ``=` `[``True``] ``*` `(``MAX` `+` `1``)` `# Stores the prime``primes ``=` `[]` `# Function to generate all``# prime numbers``def` `SieveOfEratosthenes():` `    ``global` `isPrime` `    ``p ``=` `2``    ``while` `p ``*` `p <``=` `MAX``:` `        ``# If current element is prime``        ``if` `(isPrime[p] ``=``=` `True``):` `            ``# Set all its multiples non-prime``            ``for` `i ``in` `range` `(p ``*` `p, ``MAX` `+` `1``, p):``                ``isPrime[i] ``=` `False``              ` `        ``p ``+``=` `1``      ` `    ``# Store all prime numbers``    ``for` `p ``in` `range` `(``2``, ``MAX` `+` `1``):``        ``if` `(isPrime[p]):``            ``primes.append(p)``  ` `# Function to find the closest``# prime to a particular number``def` `prime_search(primes, diff):` `    ``# Applying binary search``    ``# on primes vector``    ``low ``=` `0``    ``high ``=` `len``(primes) ``-` `1``   ` `    ``while` `(low <``=` `high):``        ``mid ``=` `(low ``+` `high) ``/``/` `2` `        ``# If the prime added makes``        ``# the elements equal``        ``if` `(primes[mid] ``=``=` `diff):` `            ``# Return this as the``            ``# closest prime``            ``return` `primes[mid]``       ` `        ``# If the array remains``        ``# non-decreasing``        ``elif` `(primes[mid] < diff):` `            ``# Search for a bigger``            ``# prime number``            ``low ``=` `mid ``+` `1``     ` `        ``# Otherwise``        ``else``:``            ``res ``=` `primes[mid]` `            ``# Check if a smaller prime  can``            ``# make array non-decreasing or not``            ``high ``=` `mid ``-` `1``       ` `    ``# Return closest number``    ``return` `res``  ` `# Function to find the minimum cost``def` `minCost(arr, n):` `    ``# Find all primes``    ``SieveOfEratosthenes()` `    ``# Store the result``    ``res ``=` `0` `    ``# Iterate over the array``    ``for` `i ``in` `range` `(``1``, n):` `        ``# Current element is less``        ``# than the previous element``        ``if` `(arr[i] < arr[i ``-` `1``]):``            ``diff ``=` `arr[i ``-` `1``] ``-` `arr[i]` `            ``# Find the closest prime which``            ``# makes the array non decreasing``            ``closest_prime ``=` `prime_search(primes, diff)` `            ``# Add to overall cost``            ``res ``+``=` `closest_prime` `            ``# Update current element``            ``arr[i] ``+``=` `closest_prime``      ` `    ``# Return the minimum cost``    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# Given array``    ``arr ``=` `[``2``, ``1``, ``5``, ``4``, ``3``]``    ``n ``=` `5` `    ``#Function Call``    ``print` `(minCost(arr, n))``   ` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement ``// the above approach ``using` `System;``using` `System.Collections;``using` `System.Collections.Generic; `` ` `class` `GFG{``   ` `static` `int` `MAX = 10000000;``  ` `// Stores if an index is a``// prime / non-prime value``static` `bool` `[]isPrime = ``new` `bool``[MAX + 1];``  ` `// Stores the prime``static` `ArrayList primes = ``new` `ArrayList();``  ` `// Function to generate all``// prime numbers``static` `void` `SieveOfEratosthenes()``{``    ``Array.Fill(isPrime, ``true``);``  ` `    ``for``(``int` `p = 2; p * p <= MAX; p++)``    ``{``          ` `        ``// If current element is prime``        ``if` `(isPrime[p] == ``true``)``        ``{``              ` `            ``// Set all its multiples non-prime``            ``for``(``int` `i = p * p; i <= MAX; i += p)``                ``isPrime[i] = ``false``;``        ``}``    ``}``  ` `    ``// Store all prime numbers``    ``for``(``int` `p = 2; p <= MAX; p++)``        ``if` `(isPrime[p])``            ``primes.Add(p);``}``  ` `// Function to find the closest``// prime to a particular number``static` `int` `prime_search(ArrayList primes,``                        ``int` `diff)``{``  ` `    ``// Applying binary search``    ``// on primes vector``    ``int` `low = 0;``    ``int` `high = primes.Count - 1;``  ` `    ``int` `res = -1;``  ` `    ``while` `(low <= high)``    ``{``        ``int` `mid = (low + high) / 2;``  ` `        ``// If the prime added makes``        ``// the elements equal``        ``if` `((``int``)primes[mid] == diff)``        ``{``              ` `            ``// Return this as the``            ``// closest prime``            ``return` `(``int``)primes[mid];``        ``}``  ` `        ``// If the array remains``        ``// non-decreasing``        ``else` `if` `((``int``)primes[mid] < diff)``        ``{``              ` `            ``// Search for a bigger``            ``// prime number``            ``low = mid + 1;``        ``}``  ` `        ``// Otherwise``        ``else``        ``{``            ``res = (``int``)primes[mid];``  ` `            ``// Check if a smaller prime can``            ``// make array non-decreasing or not``            ``high = mid - 1;``        ``}``    ``}``  ` `    ``// Return closest number``    ``return` `res;``}``  ` `// Function to find the minimum cost``static` `int` `minCost(``int` `[]arr, ``int` `n)``{``      ` `    ``// Find all primes``    ``SieveOfEratosthenes();``  ` `    ``// Store the result``    ``int` `res = 0;``  ` `    ``// Iterate over the array``    ``for``(``int` `i = 1; i < n; i++)``    ``{``          ` `        ``// Current element is less``        ``// than the previous element``        ``if` `(arr[i] < arr[i - 1])``        ``{``            ``int` `diff = arr[i - 1] - arr[i];``  ` `            ``// Find the closest prime which``            ``// makes the array non decreasing``            ``int` `closest_prime = prime_search(primes,``                                             ``diff);``  ` `            ``// Add to overall cost``            ``res += closest_prime;``  ` `            ``// Update current element``            ``arr[i] += closest_prime;``        ``}``    ``}``  ` `    ``// Return the minimum cost``    ``return` `res;``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 2, 1, 5, 4, 3 };``    ``int` `n = 5;``  ` `    ``// Function call``    ``Console.Write(minCost(arr, n));``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`7`

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

My Personal Notes arrow_drop_up