Minimum number of operations to convert a given sequence into a Geometric Progression | Set 2

• Last Updated : 20 May, 2021

Given an array arr[] consisting of N integers, the following three operations can be performed on any element one at a time:

• Add one to the element.
• Subtract one from the element.
• Leave the element unchanged.

The task is to find the minimum cost required to convert it into a Geometric Progression and also find the common ratio
Note: Each addition and subtraction operation costs 1 unit.

Examples:

Input: N = 6, arr[] = {1, 11, 4, 27, 15, 33}
Output: 28 2
Explanation:
For r = 1, arr[] = {1, 4, 11, 15, 27, 33}
expected[] = {1, 1, 1, 1, 1, 1}
cost[] = {0, 3, 10, 14, 26, 32}
Total cost: ∑ cost = 85

For r = 2, arr[] = {1, 4, 11, 15, 27, 33}
expected[] = {1, 2, 4, 8, 16, 32}
cost[] = {0, 2, 7, 7, 11, 1}
Total cost: ∑ cost = 28
For r = 3, arr[] = {1, 4, 11, 15, 27, 33}
expected[] = {1, 3, 9, 27, 81, 243}
cost[] = {0, 1, 2, 12, 54, 210}
Total cost: ∑ cost = 279

Minimum cost = 28
Common ratio = 2

Input: N = 7, arr[] = {1, 2, 4, 8, 9, 6, 7}
Output: 30 1

Approach: The idea is to iterate over range of possible common ratios and check for the minimum operations required. Follow the steps below to solve the problem:

• Sort the array.
• Find the range of possible common ratios using the formula Ceil( arr[maximum_element] / (N – 1)).
• Calculate the number of operations required for all possible common ratios.
• Find the minimum operations required for any of the common ratios.

Below is the implementation of the above approach:

C++

 // C++ program for above approach   #include using namespace std;   // Function to find minimum cost void minCost(int arr[], int n) {     if (n == 1) {         cout << 0 << endl;         return;     }       // Sort the array     sort(arr, arr + n);       // Maximum possible common ratios     float raised = 1 / float(n - 1);     float temp = pow(arr[n - 1], raised);     int r = round(temp) + 1;       int i, j, min_cost = INT_MAX;     int common_ratio = 1;       // Iterate over all possible common ratios     for (j = 1; j <= r; j++) {         int curr_cost = 0, prod = 1;           // Calculate operations required         // for the current common ratio         for (i = 0; i < n; i++) {               curr_cost += abs(arr[i] - prod);             prod *= j;             if (curr_cost >= min_cost)                 break;         }           // Calculate minimum cost         if (i == n) {             min_cost = min(min_cost,                            curr_cost);             common_ratio = j;         }     }       cout << min_cost << ' ';     cout << common_ratio << ' '; }   // Driver Code int main() {     // Given N     int N = 6;       // Given arr[]     int arr[] = { 1, 11, 4, 27, 15, 33 };       // Function Calling     minCost(arr, N);       return 0; }

Java

 // Java program for // the above approach import java.util.*; class GFG{   // Function to find minimum cost static void minCost(int arr[],                     int n) {   if (n == 1)   {     System.out.print(0 + "\n");     return;   }     // Sort the array   Arrays.sort(arr);     // Maximum possible common ratios   float raised = 1 / (float)(n - 1);   float temp = (float)Math.pow(arr[n - 1],                                raised);   int r = (int)(temp) + 1;     int i, j, min_cost = Integer.MAX_VALUE;   int common_ratio = 1;     // Iterate over all possible   // common ratios   for (j = 1; j <= r; j++)   {     int curr_cost = 0, prod = 1;       // Calculate operations required     // for the current common ratio     for (i = 0; i < n; i++)     {       curr_cost += Math.abs(arr[i] -                             prod);       prod *= j;       if (curr_cost >= min_cost)         break;     }       // Calculate minimum cost     if (i == n)     {       min_cost = Math.min(min_cost,                           curr_cost);       common_ratio = j;     }   }     System.out.print(min_cost + " ");   System.out.print(common_ratio + " "); }   // Driver Code public static void main(String[] args) {   // Given N   int N = 6;     // Given arr[]   int arr[] = {1, 11, 4,                27, 15, 33};     // Function Calling   minCost(arr, N); } }   // This code is contributed by shikhasingrajput

Python3

 # Python3 program for above approach import sys   # Function to find minimum cost def minCost(arr, n):           if (n == 1):         print(0)         return       # Sort the array     arr = sorted(arr)       # Maximum possible common ratios     raised = 1 / (n - 1)     temp = pow(arr[n - 1], raised)     r = round(temp) + 1       min_cost = sys.maxsize     common_ratio = 1       # Iterate over all possible     # common ratios     for j in range(1, r + 1):         curr_cost = 0         prod = 1           # Calculate operations required         # for the current common ratio         i = 0         while i < n:             curr_cost += abs(arr[i] - prod)             prod *= j                           if (curr_cost >= min_cost):                 break                           i += 1           # Calculate minimum cost         if (i == n):             min_cost = min(min_cost,                           curr_cost)             common_ratio = j       print(min_cost, common_ratio)   # Driver Code if __name__ == '__main__':           # Given N     N = 6       # Given arr[]     arr = [ 1, 11, 4, 27, 15, 33 ]       # Function calling     minCost(arr, N)   # This code is contributed by mohit kumar 29

C#

 // C# program for // the above approach using System;   class GFG{   // Function to find minimum cost static void minCost(int []arr,                     int n) {   if (n == 1)   {     Console.Write(0 + "\n");     return;   }     // Sort the array   Array.Sort(arr);     // Maximum possible common ratios   float raised = 1 / (float)(n - 1);   float temp = (float)Math.Pow(arr[n - 1],                                raised);   int r = (int)(temp) + 1;     int i, j, min_cost = int.MaxValue;   int common_ratio = 1;     // Iterate over all possible   // common ratios   for (j = 1; j <= r; j++)   {     int curr_cost = 0, prod = 1;       // Calculate operations required     // for the current common ratio     for (i = 0; i < n; i++)     {       curr_cost += Math.Abs(arr[i] -                             prod);       prod *= j;               if (curr_cost >= min_cost)         break;     }       // Calculate minimum cost     if (i == n)     {       min_cost = Math.Min(min_cost,                           curr_cost);       common_ratio = j;     }   }     Console.Write(min_cost + " ");   Console.Write(common_ratio + " "); }   // Driver Code public static void Main(String[] args) {       // Given N   int N = 6;     // Given []arr   int []arr = { 1, 11, 4,                 27, 15, 33 };     // Function Calling   minCost(arr, N); } }   // This code is contributed by gauravrajput1

Javascript



Output:

28 2

Time Complexity: O(N * K), where K is the maximum possible common ratio.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :