Given an array of positive integers. We need to make the given array a ‘Palindrome’. Only allowed operation on array is merge. Merging two adjacent elements means replacing them with their sum. The task is to find minimum number of merge operations required to make given array a ‘Palindrome’.
To make an array a palindromic we can simply apply merging operations n-1 times where n is the size of array (Note a single element array is alway palindrome similar to single character string). In that case, size of array will be reduced to 1. But in this problem we are asked to do it in minimum number of operations.
Example :
Input : arr[] = {15, 4, 15}
Output : 0
Array is already a palindrome. So we
do not need any merge operation.
Input : arr[] = {1, 4, 5, 1}
Output : 1
We can make given array palindrome with
minimum one merging (merging 4 and 5 to
make 9)
Input : arr[] = {11, 14, 15, 99}
Output : 3
We need to merge all elements to make
a palindrome.
Expected time complexity is O(n).
We strongly recommend that you click here and practice it, before moving on to the solution.
Let f(i, j) be minimum merging operations to make subarray arr[i..j] a palindrome. If i == j answer is 0. We start i from 0 and j from n-1.
- If arr[i] == arr[j], then there is no need to do any merging operations at index i or index j. Our answer in this case will be f(i+1, j-1).
- Else, we need to do merging operations. Following cases arise.
- If arr[i] > arr[j], then we should do merging operation at index j. We merge index j-1 and j, and update arr[j-1] = arr[j-1] + arr[j]. Our answer in this case will be 1 + f(i, j-1).
- For the case when arr[i] < arr[j], update arr[i+1] = arr[i+1] + arr[i]. Our answer in this case will be 1 + f(i+1, j).
- Our answer will be f(0, n-1), where n is size of array arr[].
Therefore this problem can be solved iteratively using two pointers (first pointer pointing to start of the array and second pointer pointing to last element of the array) method and keeping count of total merging operations done till now.
Below is implementation of above idea.
C
// C++ program to find number of operations // to make an array palindrome #include <bits/stdc++.h> using namespace std; // Returns minimum number of count operations // required to make arr[] palindrome int findMinOps(int arr[], int n) { int ans = 0; // Initialize result // Start from two corners for (int i=0,j=n-1; i<=j;) { // If corner elements are same, // problem reduces arr[i+1..j-1] if (arr[i] == arr[j]) { i++; j--; } // If left element is greater, then // we merge right two elements else if (arr[i] > arr[j]) { // need to merge from tail. j--; arr[j] += arr[j+1] ; ans++; } // Else we merge left two elements else { i++; arr[i] += arr[i-1]; ans++; } } return ans; } // Driver program to test above int main() { int arr[] = {1, 4, 5, 9, 1}; int n = sizeof(arr)/sizeof(arr[0]); cout << "Count of minimum operations is " << findMinOps(arr, n) << endl; return 0; } |
chevron_right
filter_none
Java
// Java program to find number of operations // to make an array palindrome class GFG { // Returns minimum number of count operations // required to make arr[] palindrome static int findMinOps(int[] arr, int n) { int ans = 0; // Initialize result // Start from two corners for (int i=0,j=n-1; i<=j;) { // If corner elements are same, // problem reduces arr[i+1..j-1] if (arr[i] == arr[j]) { i++; j--; } // If left element is greater, then // we merge right two elements else if (arr[i] > arr[j]) { // need to merge from tail. j--; arr[j] += arr[j+1] ; ans++; } // Else we merge left two elements else { i++; arr[i] += arr[i-1]; ans++; } } return ans; } // Driver method to test the above function public static void main(String[] args) { int arr[] = new int[]{1, 4, 5, 9, 1} ; System.out.println("Count of minimum operations is "+ findMinOps(arr, arr.length)); } } |
chevron_right
filter_none
Python
# Python program to find number of operations # to make an array palindrome # Returns minimum number of count operations # required to make arr[] palindrome def findMinOps(arr, n): ans = 0 # Initialize result # Start from two corners i,j = 0,n-1 while i<=j: # If corner elements are same, # problem reduces arr[i+1..j-1] if arr[i] == arr[j]: i += 1 j -= 1 # If left element is greater, then # we merge right two elements elif arr[i] > arr[j]: # need to merge from tail. j -= 1 arr[j] += arr[j+1] ans += 1 # Else we merge left two elements else: i += 1 arr[i] += arr[i-1] ans += 1 return ans # Driver program to test above arr = [1, 4, 5, 9, 1] n = len(arr) print("Count of minimum operations is " + str(findMinOps(arr, n))) # This code is contributed by Pratik Chhajer |
chevron_right
filter_none
C#
// C# program to find number of operations // to make an array palindrome using System; class GFG { // Returns minimum number of count operations // required to make arr[] palindrome static int findMinOps(int []arr, int n) { int ans = 0; // Initialize result // Start from two corners for (int i = 0, j = n - 1; i <= j;) { // If corner elements are same, // problem reduces arr[i+1..j-1] if (arr[i] == arr[j]) { i++; j--; } // If left element is greater, then // we merge right two elements else if (arr[i] > arr[j]) { // need to merge from tail. j--; arr[j] += arr[j + 1] ; ans++; } // Else we merge left two elements else { i++; arr[i] += arr[i-1]; ans++; } } return ans; } // Driver Code public static void Main() { int []arr = new int[]{1, 4, 5, 9, 1} ; Console.Write("Count of minimum operations is " + findMinOps(arr, arr.Length)); } } // This code is contributed by nitin mittal |
chevron_right
filter_none
PHP
<?php // PHP program to find number // of operations to make an // array palindrome // Returns minimum number of // count operations required // to make arr[] palindrome function findMinOps($arr, $n) { // Initialize result $ans = 1; // Start from two corners for ($i = 0, $j = $n - 1; $i <= $j😉 { // If corner elements are same, // problem reduces arr[i+1..j-1] if ($arr[$i] == $arr[$j]) { $i++; $j--; } // If left element is greater, then // we merge right two elements else if ($arr[$i] > $arr[$j]) { // need to merge from tail. $j--; $arr[$j] += $arr[$j + 1] ; $ans++; } // Else we merge // left two elements else { $i++; $arr[$i] += $arr[$i - 1]; $ans++; } } return $ans; } // Driver Code $arr[] = array(1, 4, 5, 9, 1); $n = sizeof($arr); echo "Count of minimum operations is ", findMinOps($arr, $n) ; // This code is contributed by nitin mittal. ?> |
chevron_right
filter_none
Output :
Count of minimum operations is 1
Time complexity for the given program is : O(n)
This article is contributed by Ashish Jain. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
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.
Recommended Posts:
- Minimum pair merge operations required to make Array non-increasing
- Merge operations using STL in C++ | merge(), includes(), set_union(), set_intersection(), set_difference(), ., inplace_merge,
- Find the minimum number of operations required to make all array elements equal
- Find minimum operations needed to make an Array beautiful
- Minimum number of deletions to make a string palindrome
- Merge Sort with O(1) extra space merge and O(n lg n) time
- Minimum gcd operations to make all array elements one
- Minimum operations to make GCD of array a multiple of k
- Minimum operations required to make all the elements distinct in an array
- Minimum operations required to make all Array elements divisible by K
- Minimum increment operations to make the array in increasing order
- Minimum Increment operations to make Array unique
- Minimum operations required to make all the array elements equal
- Minimum operations to make counts of remainders same in an array
- Make all the array elements odd with minimum operations of given type
- Minimum decrement operations to make Array elements equal by only decreasing K each time
- Minimum operations to make all elements equal using the second array
- Minimum Cost to make all array elements equal using given operations
- Minimum changes required to make each path in a matrix palindrome
- Count all palindrome which is square of a palindrome
Improved By : nitin mittal
