Skip to content
Related Articles

Related Articles

Find sub-arrays from given two arrays such that they have equal sum

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 28 May, 2022

Given two arrays A[] and B[] of equal sizes i.e. N containing integers from 1 to N. The task is to find sub-arrays from the given arrays such that they have equal sum. Print the indices of such sub-arrays. If no such sub-arrays are possible then print -1.
Examples: 
 

Input: A[] = {1, 2, 3, 4, 5}, B[] = {6, 2, 1, 5, 4} 
Output: 
Indices in array 1 : 0, 1, 2 
Indices in array 2 : 0 
A[0..2] = 1 + 2 + 3 = 6 
B[0] = 6
Input: A[] = {10, 1}, B[] = {5, 3} 
Output: -1 
No such sub-arrays. 
 

 

Approach: Let Ai denote the sum of first i elements in A and Bj denote the sum of first j elements in B. Without loss of generality we assume that An <= Bn
Now Bn >= An >= Ai. So for each Ai we can find the smallest j such that Ai <= Bj. For each i we find the difference 
Bj – Ai
If difference is 0 then we are done as the elements from 1 to i in A and 1 to j in B have the same sum. Suppose difference is not 0.Then the difference must lie in the range [1, n-1]
 

Proof: 
Let Bj – Ai >= n 
Bj >= Ai + n 
Bj-1 >= Ai (As the jth element in B can be at most n so Bj <= Bj-1 + n) 
Now this is a contradiction as we had assumed that j is the smallest index 
such that Bj >= Ai is j. So our assumption is wrong. 
So Bj – Ai < n 
 

Now there are n such differences(corresponding to each index) but only (n-1) possible values, so at least two indices will produce the same difference(By Pigeonhole principle). Let Aj – By = Ai – Bx. On rearranging we get Aj – Ai = By – Bx. So the required subarrays are [ i+1, j ] in A and [ x+1, y ] in B.
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the valid indices in the array
void printAns(int x, int y, int num)
{
    cout << "Indices in array " << num << " : ";
    for (int i = x; i < y; ++i) {
        cout << i << ", ";
    }
    cout << y << "\n";
}
 
// Function to find sub-arrays from two
// different arrays with equal sum
void findSubarray(int N, int a[], int b[], bool swap)
{
 
    // Map to store the indices in A and B
    // which produce the given difference
    std::map<int, pair<int, int> > index;
    int difference;
    index[0] = make_pair(-1, -1);
    int j = 0;
    for (int i = 0; i < N; ++i) {
 
        // Find the smallest j such that b[j] >= a[i]
        while (b[j] < a[i]) {
            j++;
        }
        difference = b[j] - a[i];
 
        // Difference encountered for the second time
        if (index.find(difference) != index.end()) {
 
            // b[j] - a[i] = b[idx.second] - a[idx.first]
            // b[j] - b[idx.second] = a[i] = a[idx.first]
            // So sub-arrays are a[idx.first+1...i] and b[idx.second+1...j]
            if (swap) {
                pair<int, int> idx = index[b[j] - a[i]];
 
                printAns(idx.second + 1, j, 1);
                printAns(idx.first + 1, i, 2);
            }
            else {
                pair<int, int> idx = index[b[j] - a[i]];
                printAns(idx.first + 1, i, 1);
                printAns(idx.second + 1, j, 2);
            }
            return;
        }
 
        // Store the indices for difference in the map
        index[difference] = make_pair(i, j);
    }
 
    cout << "-1";
}
 
// Utility function to calculate the
// cumulative sum of the array
void cumulativeSum(int arr[], int n)
{
    for (int i = 1; i < n; ++i)
        arr[i] += arr[i - 1];
}
 
// Driver code
int main()
{
    int a[] = { 1, 2, 3, 4, 5 };
    int b[] = { 6, 2, 1, 5, 4 };
    int N = sizeof(a) / sizeof(a[0]);
 
    // Function to update the arrays
    // with their cumulative sum
    cumulativeSum(a, N);
    cumulativeSum(b, N);
 
    if (b[N - 1] > a[N - 1]) {
        findSubarray(N, a, b, false);
    }
    else {
 
        // Swap is true as a and b are swapped during
        // function call
        findSubarray(N, b, a, true);
    }
 
    return 0;
}

Java




/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.*;
 
class GFG {
    // Function to print the valid indices in the array
static void printAns(int x, int y, int num)
{
    System.out.print("Indices in array " + num + " : ");
    for (int i = x; i < y; ++i) {
        System.out.print(i + ", ");
    }
    System.out.println(y);
}
 
// Function to find sub-arrays from two
// different arrays with equal sum
static void findSubarray(int N, int a[], int b[], Boolean swap)
{
 
    // Map to store the indices in A and B
    // which produce the given difference
    HashMap<Integer,ArrayList<Integer>> index = new HashMap<>();
    int difference;
    index.put(0 , new ArrayList<Integer>(Arrays.asList(-1, -1)));
    int j = 0;
    for (int i = 0; i < N; ++i) {
 
        // Find the smallest j such that b[j] >= a[i]
        while (b[j] < a[i]) {
            j++;
        }
        difference = b[j] - a[i];
 
        // Difference encountered for the second time
        if (index.containsKey(difference)) {
 
            // b[j] - a[i] = b[idx.second] - a[idx.first]
            // b[j] - b[idx.second] = a[i] = a[idx.first]
            // So sub-arrays are a[idx.first+1...i] and b[idx.second+1...j]
            if (swap) {
                ArrayList<Integer> idx = index.get(b[j] - a[i]);
 
                printAns(idx.get(1) + 1, j, 1);
                printAns(idx.get(0) + 1, i, 2);
            }
            else {
                ArrayList<Integer> idx = index.get(b[j] - a[i]);
                printAns(idx.get(0) + 1, i, 1);
                printAns(idx.get(1) + 1, j, 2);
            }
            return;
        }
 
        // Store the indices for difference in the map
        ArrayList<Integer>arr = new ArrayList<>(Arrays.asList(i,j));
    }
 
    System.out.print("-1");
}
 
// Utility function to calculate the
// cumulative sum of the array
static void cumulativeSum(int arr[], int n)
{
    for (int i = 1; i < n; ++i)
        arr[i] += arr[i - 1];
}
 
// Driver code
public static void main(String args[])
{
    int a[] = { 1, 2, 3, 4, 5 };
    int b[] = { 6, 2, 1, 5, 4 };
    int N = a.length;
 
    // Function to update the arrays
    // with their cumulative sum
    cumulativeSum(a, N);
    cumulativeSum(b, N);
 
    if (b[N - 1] > a[N - 1]) {
        findSubarray(N, a, b, false);
    }
    else {
 
        // Swap is true as a and b are swapped during
        // function call
        findSubarray(N, b, a, true);
    }
}
 
}
 
// This code is contributed by shinjanpatra

Python3




# Python3 implementation of the approach
 
# Function to print the valid indices in the array
def printAns(x, y, num):
  
    print("Indices in array", num, ":", end = " ")
    for i in range(x, y): 
        print(i, end = ", ")
      
    print(y)
 
# Function to find sub-arrays from two
# different arrays with equal sum
def findSubarray(N, a, b, swap):
  
    # Map to store the indices in A and B
    # which produce the given difference
    index = {}
    difference, j = 0, 0
    index[0] = (-1, -1)
     
    for i in range(0, N): 
 
        # Find the smallest j such that b[j] >= a[i]
        while b[j] < a[i]: 
            j += 1
          
        difference = b[j] - a[i]
 
        # Difference encountered for the second time
        if difference in index: 
 
            # b[j] - a[i] = b[idx.second] - a[idx.first]
            # b[j] - b[idx.second] = a[i] = a[idx.first]
            # So sub-arrays are a[idx.first+1...i] and b[idx.second+1...j]
            if swap: 
                idx = index[b[j] - a[i]]
                printAns(idx[1] + 1, j, 1)
                printAns(idx[0] + 1, i, 2)
              
            else:
                idx = index[b[j] - a[i]]
                printAns(idx[0] + 1, i, 1)
                printAns(idx[1] + 1, j, 2)
              
            return
          
        # Store the indices for difference in the map
        index[difference] = (i, j)
      
    print("-1")
  
# Utility function to calculate the
# cumulative sum of the array
def cumulativeSum(arr, n):
  
    for i in range(1, n):
        arr[i] += arr[i - 1]
  
# Driver code
if __name__ == "__main__":
  
    a = [1, 2, 3, 4, 5
    b = [6, 2, 1, 5, 4
    N = len(a)
 
    # Function to update the arrays
    # with their cumulative sum
    cumulativeSum(a, N)
    cumulativeSum(b, N)
 
    if b[N - 1] > a[N - 1]: 
        findSubarray(N, a, b, False)
      
    else:
 
        # Swap is true as a and b are
        # swapped during function call
        findSubarray(N, b, a, True)
 
# This code is contributed by Rituraj Jain

Javascript




<script>
 
// JavaScript implementation of the approach
 
// Function to print the valid indices in the array
function printAns(x, y, num)
{
  
    document.write("Indices in array", num, ":"," ")
    for(let i = x; i < y; i++) 
        document.write(i,", ")
      
    document.write(y,"</br>")
 
}
 
// Function to find sub-arrays from two
// different arrays with equal sum
function findSubarray(N, a, b, swap){
  
    // Map to store the indices in A and B
    // which produce the given difference
    let index = new Map();
    let difference = 0, j = 0
    index.set(0, [-1, -1])
     
    for(let i = 0; i < N; i++)
    
 
        // Find the smallest j such that b[j] >= a[i]
        while(b[j] < a[i]) 
            j += 1
          
        let difference = b[j] - a[i]
 
        // Difference encountered for the second time
        if(index.has(difference)){
 
            // b[j] - a[i] = b[idx.second] - a[idx.first]
            // b[j] - b[idx.second] = a[i] = a[idx.first]
            // So sub-arrays are a[idx.first+1...i] and b[idx.second+1...j]
            if(swap){ 
                let idx = index.get(b[j] - a[i])
                printAns(idx[1] + 1, j, 1)
                printAns(idx[0] + 1, i, 2)
            }
              
            else{
                let idx = index.get(b[j] - a[i])
                printAns(idx[0] + 1, i, 1)
                printAns(idx[1] + 1, j, 2)
            }
              
            return
          
        // Store the indices for difference in the map
        }
        index.set(difference,[i, j])
    }
      
    document.write("-1")
 
}
  
// Utility function to calculate the
// cumulative sum of the array
function cumulativeSum(arr, n){
  
    for(let i = 1; i < n; i++)
        arr[i] += arr[i - 1]
  
}
 
// Driver code
  
let a = [1, 2, 3, 4, 5] 
let b = [6, 2, 1, 5, 4] 
let N = a.length
 
// Function to update the arrays
// with their cumulative sum
cumulativeSum(a, N)
cumulativeSum(b, N)
 
if(b[N - 1] > a[N - 1])
    findSubarray(N, a, b, false)
      
else
 
    // Swap is true as a and b are
    // swapped during function call
    findSubarray(N, b, a, true)
 
// This code is contributed by shinjanpatra
 
</script>

Output: 

Indices in array 1 : 0, 1, 2
Indices in array 2 : 0

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!