Split array to three subarrays such that sum of first and third subarray is equal and maximum
Last Updated :
19 Oct, 2022
Given an array of N integers, the task is to print the sum of the first subarray by splitting the array into exactly three subarrays such that the sum of the first and third subarray elements are equal and the maximum.
Note: All the elements must belong to a subarray and the subarrays can also be empty.
Examples:
Input: a[] = {1, 3, 1, 1, 4}
Output: 5
Split the N numbers to [1, 3, 1], [] and [1, 4]
Input: a[] = {1, 3, 2, 1, 4}
Output: 4
Split the N numbers to [1, 3], [2, 1] and [4]
METHOD 1
A naive approach is to check for all possible partitions and use the prefix-sum concept to find out the partitions. The partition which gives the maximum sum of the first subarray will be the answer.
An efficient approach is as follows:
- Store the prefix sum and suffix sum of the N numbers.
- Hash the suffix sum's index using a unordered_map in C++ or Hash-map in Java.
- Iterate from the beginning of the array, and check if the prefix sum exists in the suffix array beyond the current index i.
- If it does, then check for the previous maximum value and update accordingly.
Below is the implementation of the above approach:
C++
// C++ program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
#include <bits/stdc++.h>
using namespace std;
// Function to return the sum of
// the first subarray
int sumFirst(int a[], int n)
{
unordered_map<int, int> mp;
int suf = 0;
// calculate the suffix sum
for (int i = n - 1; i >= 0; i--)
{
suf += a[i];
mp[suf] = i;
}
int pre = 0;
int maxi = -1;
// iterate from beginning
for (int i = 0; i < n; i++)
{
// prefix sum
pre += a[i];
// check if it exists beyond i
if (mp[pre] > i)
{
// if greater then previous
// then update maximum
if (pre > maxi)
{
maxi = pre;
}
}
}
// First and second subarray empty
if (maxi == -1)
return 0;
// partition done
else
return maxi;
}
// Driver Code
int main()
{
int a[] = { 1, 3, 2, 1, 4 };
int n = sizeof(a) / sizeof(a[0]);
// Function call
cout << sumFirst(a, n);
return 0;
}
// Java program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
import java.util.HashMap;
import java.util.Map;
class GfG {
// Function to return the sum
// of the first subarray
static int sumFirst(int a[], int n)
{
HashMap<Integer, Integer> mp = new HashMap<>();
int suf = 0;
// calculate the suffix sum
for (int i = n - 1; i >= 0; i--)
{
suf += a[i];
mp.put(suf, i);
}
int pre = 0, maxi = -1;
// iterate from beginning
for (int i = 0; i < n; i++)
{
// prefix sum
pre += a[i];
// check if it exists beyond i
if (mp.containsKey(pre) && mp.get(pre) > i)
{
// if greater then previous
// then update maximum
if (pre > maxi)
{
maxi = pre;
}
}
}
// First and second subarray empty
if (maxi == -1)
return 0;
// partition done
else
return maxi;
}
// Driver code
public static void main(String[] args)
{
int a[] = { 1, 3, 2, 1, 4 };
int n = a.length;
// Function call
System.out.println(sumFirst(a, n));
}
}
// This code is contributed by Rituraj Jain
# Python3 program for Split the array into three
# subarrays such that summation of first
# and third subarray is equal and maximum
# Function to return the sum of
# the first subarray
def sumFirst(a, n):
mp = {i: 0 for i in range(7)}
suf = 0
i = n - 1
# calculate the suffix sum
while(i >= 0):
suf += a[i]
mp[suf] = i
i -= 1
pre = 0
maxi = -1
# iterate from beginning
for i in range(n):
# prefix sum
pre += a[i]
# check if it exists beyond i
if (mp[pre] > i):
# if greater then previous
# then update maximum
if (pre > maxi):
maxi = pre
# First and second subarray empty
if (maxi == -1):
return 0
# partition done
else:
return maxi
# Driver Code
if __name__ == '__main__':
a = [1, 3, 2, 1, 4]
n = len(a)
# Function call
print(sumFirst(a, n))
# This code is contributed by
# Surendra_Gangwar
// C# program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
using System;
using System.Collections.Generic;
class GfG {
// Function to return the sum
// of the first subarray
static int sumFirst(int[] a, int n)
{
Dictionary<int, int> mp
= new Dictionary<int, int>();
int suf = 0;
// calculate the suffix sum
for (int i = n - 1; i >= 0; i--)
{
suf += a[i];
mp.Add(suf, i);
if (mp.ContainsKey(suf))
{
mp.Remove(suf);
}
mp.Add(suf, i);
}
int pre = 0, maxi = -1;
// iterate from beginning
for (int i = 0; i < n; i++)
{
// prefix sum
pre += a[i];
// check if it exists beyond i
if (mp.ContainsKey(pre) && mp[pre] > i)
{
// if greater then previous
// then update maximum
if (pre > maxi)
{
maxi = pre;
}
}
}
// First and second subarray empty
if (maxi == -1)
return 0;
// partition done
else
return maxi;
}
// Driver code
public static void Main(String[] args)
{
int[] a = { 1, 3, 2, 1, 4 };
int n = a.Length;
// Function call
Console.WriteLine(sumFirst(a, n));
}
}
// This code is contributed by Rajput-Ji
<script>
// JavaScript program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
// Function to return the sum of
// the first subarray
function sumFirst(a, n)
{
var mp = new Map();
var suf = 0;
// calculate the suffix sum
for (var i = n - 1; i >= 0; i--)
{
suf += a[i];
mp.set(suf, i);
}
var pre = 0;
var maxi = -1;
// iterate from beginning
for (var i = 0; i < n; i++)
{
// prefix sum
pre += a[i];
// check if it exists beyond i
if (mp.get(pre) > i)
{
// if greater then previous
// then update maximum
if (pre > maxi)
{
maxi = pre;
}
}
}
// First and second subarray empty
if (maxi == -1)
return 0;
// partition done
else
return maxi;
}
// Driver Code
var a = [1, 3, 2, 1, 4];
var n = a.length;
// Function call
document.write( sumFirst(a, n));
</script>
Time Complexity: O(n) where n is the size of the given array
Auxiliary Space: O(n)
METHOD 2
Approach: We will use two pointers concept where one pointer will start from the front and the other from the back. In each iteration, the sum of the first and last subarray is compared and if they are the same then the sum is updated in the answer variable.
Algorithm:
- Initialize front_pointer to 0 and back_pointer to n-1.
- Initialize prefixsum to arr[ front_pointer ] and suffixsum to arr[back_pointer].
- The summations are compared.
- If prefixsum > suffixsum ,back_pointer is decremented by 1 and suffixsum+= arr[ back_pointer ].
- If prefixsum < suffixsum, front_pointer is incremented by 1 and prefixsum+= arr[ front_pointer ]
- If they are the same then the sum is updated in the answer variable and both the pointers are moved by one step and both prefixsum and suffixsum are updated accordingly.
- The above step is continued until the front_pointer is no less than the back_pointer.
Below is the implementation of the above approach:
C++
// C++ program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
#include <bits/stdc++.h>
using namespace std;
// Function to return the sum of
// the first subarray
int sumFirst(int a[], int n)
{
// two pointers are initialized
// one at the front and the other
// at the back
int front_pointer = 0;
int back_pointer = n - 1;
// prefixsum and suffixsum initialized
int prefixsum = a[front_pointer];
int suffixsum = a[back_pointer];
// answer variable initialized to 0
int answer = 0;
while (front_pointer < back_pointer)
{
// if the summation are equal
if (prefixsum == suffixsum)
{
// answer updated
answer = max(answer, prefixsum);
// both the pointers are moved by step
front_pointer++;
back_pointer--;
// prefixsum and suffixsum are updated
prefixsum += a[front_pointer];
suffixsum += a[back_pointer];
}
else if (prefixsum > suffixsum)
{
// if prefixsum is more,then back pointer is
// moved by one step and suffixsum updated.
back_pointer--;
suffixsum += a[back_pointer];
}
else
{
// if prefixsum is less,then front pointer is
// moved by one step and prefixsum updated.
front_pointer++;
prefixsum += a[front_pointer];
}
}
// answer is returned
return answer;
}
// Driver code
int main()
{
int arr[] = { 1, 3, 2, 1, 4 };
int n = sizeof(arr) / sizeof(arr[0]);
// Function call
cout << sumFirst(arr, n);
// This code is contributed by Arif
}
// Java program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
import java.util.*;
class GFG{
// Function to return the sum of
// the first subarray
public static int sumFirst(int a[], int n)
{
// Two pointers are initialized
// one at the front and the other
// at the back
int front_pointer = 0;
int back_pointer = n - 1;
// prefixsum and suffixsum initialized
int prefixsum = a[front_pointer];
int suffixsum = a[back_pointer];
// answer variable initialized to 0
int answer = 0;
while (front_pointer < back_pointer)
{
// If the summation are equal
if (prefixsum == suffixsum)
{
// answer updated
answer = Math.max(answer, prefixsum);
// Both the pointers are moved by step
front_pointer++;
back_pointer--;
// prefixsum and suffixsum are updated
prefixsum += a[front_pointer];
suffixsum += a[back_pointer];
}
else if (prefixsum > suffixsum)
{
// If prefixsum is more,then back pointer is
// moved by one step and suffixsum updated.
back_pointer--;
suffixsum += a[back_pointer];
}
else
{
// If prefixsum is less,then front pointer is
// moved by one step and prefixsum updated.
front_pointer++;
prefixsum += a[front_pointer];
}
}
// answer is returned
return answer;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 3, 2, 1, 4 };
int n = arr.length;
// Function call
System.out.print(sumFirst(arr, n));
}
}
// This code is contributed by divyeshrabadiya07
# Python3 program for Split the array into three
# subarrays such that summation of first
# and third subarray is equal and maximum
import math
# Function to return the sum of
# the first subarray
def sumFirst(a, n):
# Two pointers are initialized
# one at the front and the other
# at the back
front_pointer = 0
back_pointer = n - 1
# prefixsum and suffixsum initialized
prefixsum = a[front_pointer]
suffixsum = a[back_pointer]
# answer variable initialized to 0
answer = 0
while (front_pointer < back_pointer):
# If the summation are equal
if (prefixsum == suffixsum):
# answer updated
answer = max(answer, prefixsum)
# Both the pointers are moved by step
front_pointer += 1
back_pointer -= 1
# prefixsum and suffixsum are updated
prefixsum += a[front_pointer]
suffixsum += a[back_pointer]
elif (prefixsum > suffixsum):
# If prefixsum is more,then back pointer is
# moved by one step and suffixsum updated.
back_pointer -= 1
suffixsum += a[back_pointer]
else:
# If prefixsum is less,then front pointer is
# moved by one step and prefixsum updated.
front_pointer += 1
prefixsum += a[front_pointer]
# answer is returned
return answer
# Driver code
arr = [ 1, 3, 2, 1, 4 ]
n = len(arr)
# Function call
print(sumFirst(arr, n))
# This code is contributed by Stream_Cipher
// C# program for split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
using System;
class GFG{
// Function to return the sum of
// the first subarray
static int sumFirst(int[] a, int n)
{
// Two pointers are initialized
// one at the front and the other
// at the back
int front_pointer = 0;
int back_pointer = n - 1;
// prefixsum and suffixsum initialized
int prefixsum = a[front_pointer];
int suffixsum = a[back_pointer];
// answer variable initialized to 0
int answer = 0;
while (front_pointer < back_pointer)
{
// If the summation are equal
if (prefixsum == suffixsum)
{
// answer updated
answer = Math.Max(answer, prefixsum);
// Both the pointers are moved by step
front_pointer++;
back_pointer--;
// prefixsum and suffixsum are updated
prefixsum += a[front_pointer];
suffixsum += a[back_pointer];
}
else if (prefixsum > suffixsum)
{
// If prefixsum is more,then back pointer is
// moved by one step and suffixsum updated.
back_pointer--;
suffixsum += a[back_pointer];
}
else
{
// If prefixsum is less,then front pointer is
// moved by one step and prefixsum updated.
front_pointer++;
prefixsum += a[front_pointer];
}
}
// answer is returned
return answer;
}
// Driver Code
static void Main()
{
int[] arr = { 1, 3, 2, 1, 4 };
int n = arr.Length;
// Function call
Console.WriteLine(sumFirst(arr, n));
}
}
// This code is contributed by divyesh072019
<script>
// javascript program for Split the array into three
// subarrays such that summation of first
// and third subarray is equal and maximum
// Function to return the sum of
// the first subarray
function sumFirst(a, n)
{
// Two pointers are initialized
// one at the front and the other
// at the back
var front_pointer = 0;
var back_pointer = n - 1;
// prefixsum and suffixsum initialized
var prefixsum = a[front_pointer];
var suffixsum = a[back_pointer];
// answer variable initialized to 0
var answer = 0;
while (front_pointer < back_pointer)
{
// If the summation are equal
if (prefixsum == suffixsum)
{
// answer updated
answer = Math.max(answer, prefixsum);
// Both the pointers are moved by step
front_pointer++;
back_pointer--;
// prefixsum and suffixsum are updated
prefixsum += a[front_pointer];
suffixsum += a[back_pointer];
}
else if (prefixsum > suffixsum)
{
// If prefixsum is more,then back pointer is
// moved by one step and suffixsum updated.
back_pointer--;
suffixsum += a[back_pointer];
}
else
{
// If prefixsum is less,then front pointer is
// moved by one step and prefixsum updated.
front_pointer++;
prefixsum += a[front_pointer];
}
}
// answer is returned
return answer;
}
// Driver code
var arr = [ 1, 3, 2, 1, 4 ];
var n = arr.length;
// Function call
document.write(sumFirst(arr, n));
// This code is contributed by todaysgaurav
</script>
Complexity Analysis:
- Time Complexity: O(n)
- Auxiliary Space: O(1)
Similar Reads
Split array into K subarrays such that sum of maximum of all subarrays is maximized
Given an array arr[] of size N and a number K, the task is to partition the given array into K contiguous subarrays such that the sum of the maximum of each subarray is the maximum possible. If it is possible to split the array in such a manner, then print the maximum possible sum. Otherwise, print
10 min read
Count ways to split an array into subarrays such that sum of the i-th subarray is divisible by i
Given an array arr[] consisting of N integers, the task is to find the number of ways to split the array into non-empty subarrays such that the sum of the ith subarray is divisible by i. Examples: Input: arr[] = {1, 2, 3, 4}Output: 3Explanation:Following are the number of ways to split the array int
8 min read
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
Given an array arr[] consisting of N integers, the task is to maximize the sum of the difference of the maximum and minimum in each subarrays by splitting the given array into non-overlapping subarrays. Examples: Input: arr[] = {8, 1, 7, 9, 2}Output: 14Explanation:Split the given array arr[] as {8,
6 min read
Split Array into maximum Subarrays so that sum of alternating sums is 0
Given an array arr[] of 1s and -1s, the task is to partition the array into maximum subarrays such that the sum of the alternating sum of all the subarrays is 0. Print the ranges of the subarrays and the number of subarrays. Note: The alternating sum of a subarray a[] is defined as a[0] - a[1] + a[2
7 min read
Split into K subarrays to minimize the maximum sum of all subarrays
Given an array arr[] and a number k, split the given array into k subarrays such that the maximum subarray sum achievable out of k subarrays formed is the minimum possible. The task is to find that possible subarray sum.Examples:Input: arr[] = [1, 2, 3, 4], k = 3 Output: 4 Explanation: Optimal Split
11 min read
First subarray having sum at least half the maximum sum of any subarray of size K
Given an array arr[] and an integer K, the task is to find the first subarray which has a sum greater than or equal to half of the maximum possible sum from any subarray of size K. Examples: Input: arr[] = {2, 4, 5, 1, 4, 6, 6, 2, 1, 0}, K = 3 Output: 6 2 1 Explanation: The given array has a maximum
9 min read
Split array into subarrays such that sum of difference between their maximums and minimums is maximum
Given an array arr[] consisting of N integers, the task is to split the array into subarrays such that the sum of the difference between the maximum and minimum elements for all the subarrays is maximum. Examples : Input: arr[] = {8, 1, 7, 9, 2}Output: 14Explanation:Consider splitting the given arra
6 min read
Split array into maximum subarrays such that every distinct element lies in a single subarray
Given an array, arr[] of size N, the task is to split the array into the maximum number of subarrays such that the first and the last occurrence of all distinct array element lies in a single subarray. Examples: Input: arr[] = {1, 1, 2, 2}Output: 2Explanation:Split the array into subarrays {1, 1} an
6 min read
Split array into K non-empty subsets such that sum of their maximums and minimums is maximized
Given two arrays arr[] and S[] consisting of N and K integers, the task is to find the maximum sum of minimum and maximum of each subset after splitting the array into K subsets such that the size of each subset is equal to one of the elements in the array S[]. Examples: Input: arr[] = {1, 13, 7, 17
7 min read
Maximum subarray size having all subarrays sums less than k
Given an array of positive integers arr[] of size n, and an integer k. The task is to find the maximum subarray size such that all subarrays of that size have sum less than or equals to k.Examples : Input : arr[] = [1, 2, 3, 4], k = 8.Output : 2Explanation: Following are the sum of subarray of size
15+ min read