Maximum Subarray Sum Excluding Certain Elements

Given an array of A of n integers and an array B of m integers find the Maximum Contiguous Subarray Sum of array A such that any element of array B is not present in that subarray.

Examples :

Input : A = {1, 7, -10, 6, 2}, B = {5, 6, 7, 1} 
Output : 2 
Explanation Since the Maximum Sum Subarray of A is not allowed to have any element that is present in array B. 
The Maximum Sum Subarray satisfying this is {2} as the only allowed subarrays are:{-10} and {2}. The Maximum Sum Subarray being {2} which sums to 2

Input : A = {3, 4, 5, -4, 6}, B = {1, 8, 5} 
Output : 7
Explanation
The Maximum Sum Subarray satisfying this is {3, 4} as the only allowed subarrays are {3}, {4}, {3, 4}, {-4}, {6}, {-4, 6}. The Maximum Sum subarray being {3, 4} which sums to 7

Method 1 (O(n*m) approach):

We can solve this problem using the Kadane’s Algorithm. Since we don’t want any of the elements of array B to be part of any subarray of A, we need to modify the classical Kadane’s Algorithm a little.

Whenever we consider an element in the Kadane’s algorithm we either extend current subarray or we start a new subarray. 

curr_max = max(a[i], curr_max+a[i]);
if (curr_max < 0)
   curr_max = 0

Now, in this problem when we consider any element, we check by linearly searching in the array B, if that element is present in B then we set curr_max to zero which means that at that index all subarrays we considered upto that point would end and not be extended further as no further contiguous arrays can be formed, i.e 

If A_i is present in B, all subarrays in A from 0 to (i – 1) cannot be extended further as, the i^th element can never be included in any subarray

If the current element of array A is not part of array B, we proceed with the Kadane’s Algorithm and keep track of the max_so_far.

Implementation:

C++

// C++ Program to find max subarray
// sum excluding some elements
#include <bits/stdc++.h>
using namespace std;

// Function to check the element
// present in array B
bool isPresent(int B[], int m, int x)
{
    for (int i = 0; i < m; i++)
        if (B[i] == x)
            return true;
    return false;
}

// Utility function for findMaxSubarraySum()
// with the following parameters
// A => Array A,
// B => Array B,
// n => Number of elements in Array A,
// m => Number of elements in Array B
int findMaxSubarraySumUtil(int A[], int B[], int n, int m)
{

    // set max_so_far to INT_MIN
    int max_so_far = INT_MIN, curr_max = 0;

    for (int i = 0; i < n; i++)
    {
        // if the element is present in B,
        // set current max to 0 and move to
        // the next element */
        if (isPresent(B, m, A[i]))
        {
            curr_max = 0;
            continue;
        }

        // Proceed as in Kadane's Algorithm
        curr_max = max(A[i], curr_max + A[i]);
        max_so_far = max(max_so_far, curr_max);
    }
    return max_so_far;
}

// Wrapper for findMaxSubarraySumUtil()
void findMaxSubarraySum(int A[], int B[], int n, int m)
{
    int maxSubarraySum = findMaxSubarraySumUtil(A, B, n, m);

    // This case will occur when all elements
    // of A are present in B, thus
    // no subarray can be formed
    if (maxSubarraySum == INT_MIN)
    {
        cout << "Maximum Subarray Sum cant be found"
             << endl;
    }
    else
    {
        cout << "The Maximum Subarray Sum = "
             << maxSubarraySum << endl;
    }
}

// Driver Code
int main()
{
    int A[] = { 3, 4, 5, -4, 6 };
    int B[] = { 1, 8, 5 };

    int n = sizeof(A) / sizeof(A[0]);
    int m = sizeof(B) / sizeof(B[0]);

    // Function call
    findMaxSubarraySum(A, B, n, m);

    return 0;
}

Java

// Java Program to find max subarray
// sum excluding some elements
import java.io.*;

class GFG {

    // Function to check the element
    // present in array B
    static boolean isPresent(int B[], int m, int x)
    {
        for (int i = 0; i < m; i++)
            if (B[i] == x)
                return true;

        return false;
    }

    // Utility function for findMaxSubarraySum()
    // with the following parameters
    // A => Array A,
    // B => Array B,
    // n => Number of elements in Array A,
    // m => Number of elements in Array B
    static int findMaxSubarraySumUtil(int A[], int B[],
                                      int n, int m)
    {

        // set max_so_far to INT_MIN
        int max_so_far = -2147483648, curr_max = 0;

        for (int i = 0; i < n; i++)
        {

            // if the element is present in B,
            // set current max to 0 and move to
            // the next element
            if (isPresent(B, m, A[i]))
            {
                curr_max = 0;
                continue;
            }

            // Proceed as in Kadane's Algorithm
            curr_max = Math.max(A[i], curr_max + A[i]);
            max_so_far = Math.max(max_so_far, curr_max);
        }
        return max_so_far;
    }

    // Wrapper for findMaxSubarraySumUtil()
    static void findMaxSubarraySum(int A[], int B[], int n,
                                   int m)
    {
        int maxSubarraySum
            = findMaxSubarraySumUtil(A, B, n, m);

        // This case will occur when all
        // elements of A are present
        // in B, thus no subarray can be formed
        if (maxSubarraySum == -2147483648)
        {
            System.out.println("Maximum Subarray Sum"
                               + " "
                               + "can't be found");
        }
        else {
            System.out.println("The Maximum Subarray Sum = "
                               + maxSubarraySum);
        }
    }

    // Driver code
    public static void main(String[] args)
    {

        int A[] = { 3, 4, 5, -4, 6 };
        int B[] = { 1, 8, 5 };

        int n = A.length;
        int m = B.length;

        // Function call
        findMaxSubarraySum(A, B, n, m);
    }
}

// This code is contributed by Ajit.

Python3

# Python Program to find max
# subarray sum excluding some
# elements

# Function to check the element
# present in array B
INT_MIN = -2147483648


def isPresent(B, m, x):
    for i in range(0, m):
        if B[i] == x:
            return True
    return False

# Utility function for findMaxSubarraySum()
# with the following parameters
# A => Array A,
# B => Array B,
# n => Number of elements in Array A,
# m => Number of elements in Array B


def findMaxSubarraySumUtil(A, B, n, m):

    # set max_so_far to INT_MIN
    max_so_far = INT_MIN
    curr_max = 0
    for i in range(0, n):
        if isPresent(B, m, A[i]) == True:
            curr_max = 0
            continue

        # Proceed as in Kadane's Algorithm
        curr_max = max(A[i], curr_max + A[i])
        max_so_far = max(max_so_far, curr_max)
    return max_so_far

# Wrapper for findMaxSubarraySumUtil()


def findMaxSubarraySum(A, B, n, m):

    maxSubarraySum = findMaxSubarraySumUtil(A, B, n, m)

    # This case will occur when all
    # elements of A are present
    # in B, thus no subarray can be
    # formed
    if maxSubarraySum == INT_MIN:
        print('Maximum Subarray Sum cant be found')
    else:
        print('The Maximum Subarray Sum =',
              maxSubarraySum)


# Driver code
A = [3, 4, 5, -4, 6]
B = [1, 8, 5]
n = len(A)
m = len(B)

# Function call
findMaxSubarraySum(A, B, n, m)

# This code is contributed
# by sahil shelangia

C#

// C# Program to find max subarray
// sum excluding some elements
using System;

class GFG {

    // Function to check the element
    // present in array B
    static bool isPresent(int[] B, int m, int x)
    {
        for (int i = 0; i < m; i++)
            if (B[i] == x)
                return true;

        return false;
    }

    // Utility function for findMaxSubarraySum()
    // with the following parameters
    // A => Array A,
    // B => Array B,
    // n => Number of elements in Array A,
    // m => Number of elements in Array B
    static int findMaxSubarraySumUtil(int[] A, int[] B,
                                      int n, int m)
    {

        // set max_so_far to INT_MIN
        int max_so_far = -2147483648, curr_max = 0;

        for (int i = 0; i < n; i++)
        {

            // if the element is present in B,
            // set current max to 0 and move to
            // the next element
            if (isPresent(B, m, A[i]))
            {
                curr_max = 0;
                continue;
            }

            // Proceed as in Kadane's Algorithm
            curr_max = Math.Max(A[i], curr_max + A[i]);
            max_so_far = Math.Max(max_so_far, curr_max);
        }
        return max_so_far;
    }

    // Wrapper for findMaxSubarraySumUtil()
    static void findMaxSubarraySum(int[] A, int[] B, int n,
                                   int m)
    {
        int maxSubarraySum
            = findMaxSubarraySumUtil(A, B, n, m);

        // This case will occur when all
        // elements of A are present
        // in B, thus no subarray can be formed
        if (maxSubarraySum == -2147483648)
        {
            Console.Write("Maximum Subarray Sum"
                          + " "
                          + "can't be found");
        }
        else {
            Console.Write("The Maximum Subarray Sum = "
                          + maxSubarraySum);
        }
    }

    // Driver Code
    static public void Main()
    {

        int[] A = { 3, 4, 5, -4, 6 };
        int[] B = { 1, 8, 5 };

        int n = A.Length;
        int m = B.Length;

        // Function call
        findMaxSubarraySum(A, B, n, m);
    }
}

// This code is contributed by Shrikant13.

PHP

<?php
// PHP Program to find max subarray
// sum excluding some elements

// Function to check the element
// present in array B
function isPresent($B, $m, $x)
{
    for ($i = 0; $i < $m; $i++)
        if ($B[$i] == $x)
            return true;
    return false;
}

// Utility function for
// findMaxSubarraySum()
// with the following
// parameters
// A => Array A,
// B => Array B,
// n => Number of elements
//      in Array A,
// m => Number of elements
//      in Array B
function findMaxSubarraySumUtil($A, $B,
                                $n, $m)
{

    // set max_so_far
    // to INT_MIN
    $max_so_far = PHP_INT_MIN;
    $curr_max = 0;

    for ($i = 0; $i < $n; $i++)
    {

        // if the element is present
        // in B, set current max to
        // 0 and move to the next
        // element
        if (isPresent($B, $m, $A[$i]))
        {
            $curr_max = 0;
            continue;
        }

        // Proceed as in
        // Kadane's Algorithm
        $curr_max = max($A[$i],
        $curr_max + $A[$i]);
        $max_so_far = max($max_so_far,
                          $curr_max);
    }
    return $max_so_far;
}

// Wrapper for
// findMaxSubarraySumUtil()
function findMaxSubarraySum($A, $B,
                            $n, $m)
{
    $maxSubarraySum = findMaxSubarraySumUtil($A, $B,
                                             $n, $m);

    // This case will occur
    // when all elements of
    // A are present in
    // B, thus no subarray
    // can be formed
    if ($maxSubarraySum == PHP_INT_MIN)
    {
        echo ("Maximum Subarray " .
            "Sum cant be found\n");
    }
    else
    {
        echo ("The Maximum Subarray Sum = ".
                     $maxSubarraySum. "\n");
    }
}

// Driver Code
$A = array(3, 4, 5, -4, 6);
$B = array(1, 8, 5);

$n = count($A);
$m = count($B);

// Function call
findMaxSubarraySum($A, $B, $n, $m);

// This code is contributed by
// Manish Shaw(manishshaw1)
?>

Javascript

<script>

// JavaScript Program to find max subarray
// sum excluding some elements

    // Function to check the element
    // present in array B
    function isPresent(B, m, x)
    {
        for (let i = 0; i < m; i++)
            if (B[i] == x)
                return true;

        return false;
    }

    // Utility function for findMaxSubarraySum()
    // with the following parameters
    // A => Array A,
    // B => Array B,
    // n => Number of elements in Array A,
    // m => Number of elements in Array B
    function findMaxSubarraySumUtil(A, B,n, m)
    {

        // set max_so_far to LET_MIN
        let max_so_far = -2147483648, curr_max = 0;

        for (let i = 0; i < n; i++)
        {

            // if the element is present in B,
            // set current max to 0 and move to
            // the next element
            if (isPresent(B, m, A[i]))
            {
                curr_max = 0;
                continue;
            }

            // Proceed as in Kadane's Algorithm
            curr_max = Math.max(A[i], curr_max + A[i]);
            max_so_far = Math.max(max_so_far, curr_max);
        }
        return max_so_far;
    }

    // Wrapper for findMaxSubarraySumUtil()
    function findMaxSubarraySum(A, B, n,
                                   m)
    {
        let maxSubarraySum
            = findMaxSubarraySumUtil(A, B, n, m);

        // This case will occur when all
        // elements of A are present
        // in B, thus no subarray can be formed
        if (maxSubarraySum == -2147483648)
        {
            document.write("Maximum Subarray Sum"
                               + " "
                               + "can't be found");
        }
        else {
            document.write("The Maximum Subarray Sum = "
                               + maxSubarraySum);
        }
    }


// Driver code

         let A = [ 3, 4, 5, -4, 6 ];
        let B = [ 1, 8, 5 ];

        let n = A.length;
        let m = B.length;

        // Function call
        findMaxSubarraySum(A, B, n, m);

        // This code is contributed by code_hunt.
</script>

Output

The Maximum Subarray Sum = 7

Time Complexity:  O(n*m)
Auxiliary Space: O(1)

Method 2 (O((n+m)*log(m)) approach):

The main idea behind this approach is exactly the same as that of method 1. This approach just makes the searching of an element of array A, in array B, faster by using Binary Search

Note: We need to sort the Array B to apply Binary Search on it.

Implementation:

C++

// C++ Program to find max subarray
// sum excluding some elements
#include <bits/stdc++.h>
using namespace std;

// Utility function for findMaxSubarraySum()
// with the following parameters
// A => Array A,
// B => Array B,
// n => Number of elements in Array A,
// m => Number of elements in Array B
int findMaxSubarraySumUtil(int A[], int B[], int n, int m)
{

    // set max_so_far to INT_MIN
    int max_so_far = INT_MIN, curr_max = 0;

    for (int i = 0; i < n; i++) {

        // if the element is present in B,
        // set current max to 0 and move to
        // the next element
        if (binary_search(B, B + m, A[i])) {
            curr_max = 0;
            continue;
        }

        // Proceed as in Kadane's Algorithm
        curr_max = max(A[i], curr_max + A[i]);
        max_so_far = max(max_so_far, curr_max);
    }
    return max_so_far;
}

// Wrapper for findMaxSubarraySumUtil()
void findMaxSubarraySum(int A[], int B[], int n, int m)
{
    // sort array B to apply Binary Search
    sort(B, B + m);

    int maxSubarraySum = findMaxSubarraySumUtil(A, B, n, m);

    // This case will occur when all elements
    // of A are present in B, thus no subarray
    // can be formed
    if (maxSubarraySum == INT_MIN) {
        cout << "Maximum subarray sum cant be found"
             << endl;
    }
    else {
        cout << "The Maximum subarray sum = "
             << maxSubarraySum << endl;
    }
}

// Driver Code
int main()
{
    int A[] = { 3, 4, 5, -4, 6 };
    int B[] = { 1, 8, 5 };

    int n = sizeof(A) / sizeof(A[0]);
    int m = sizeof(B) / sizeof(B[0]);

    // Function call
    findMaxSubarraySum(A, B, n, m);
    return 0;
}

Java

// Java Program to find max subarray
// sum excluding some elements
import java.util.*;

class GFG {

    // Utility function for findMaxSubarraySum()
    // with the following parameters
    // A => Array A,
    // B => Array B,
    // n => Number of elements in Array A,
    // m => Number of elements in Array B
    static int findMaxSubarraySumUtil(int A[], int B[],
                                      int n, int m)
    {

        // set max_so_far to INT_MIN
        int max_so_far = Integer.MIN_VALUE, curr_max = 0;

        for (int i = 0; i < n; i++)
        {
            // if the element is present in B,
            // set current max to 0 and move to
            // the next element
            if (Arrays.binarySearch(B, A[i]) >= 0)
            {
                curr_max = 0;
                continue;
            }

            // Proceed as in Kadane's Algorithm
            curr_max = Math.max(A[i], curr_max + A[i]);
            max_so_far = Math.max(max_so_far, curr_max);
        }
        return max_so_far;
    }

    // Wrapper for findMaxSubarraySumUtil()
    static void findMaxSubarraySum(int A[], int B[], int n,
                                   int m)
    {
        // sort array B to apply Binary Search
        Arrays.sort(B);

        int maxSubarraySum
            = findMaxSubarraySumUtil(A, B, n, m);

        // This case will occur when all elements
        // of A are present in B, thus no subarray
        // can be formed
        if (maxSubarraySum == Integer.MIN_VALUE)
        {
            System.out.println(
                "Maximum subarray sum cant be found");
        }
        else
        {
            System.out.println("The Maximum subarray sum = "
                               + maxSubarraySum);
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        int A[] = { 3, 4, 5, -4, 6 };
        int B[] = { 1, 8, 5 };

        int n = A.length;
        int m = B.length;

        // Function call
        findMaxSubarraySum(A, B, n, m);
    }
}

// This code has been contributed by 29AjayKumar

Python3

# Python Program to find max subarray
# sum excluding some elements

# Utility function for findMaxSubarraySum()
# with the following parameters
# A => Array A,
# B => Array B,
# n => Number of elements in Array A,
# m => Number of elements in Array B
import sys


def binary_search(B, m, target):

    start,end = 0,m - 1

    # Iterate while start not meets end
    while (start <= end):

        # Find the mid index
        mid = (start + end) // 2

        # If element is present at mid, return True
        if (B[mid] == target):
            return True

        # Else look in left or right half accordingly
        elif (B[mid] < target):
            start = mid + 1
        else:
            end = mid - 1

    return False

def findMaxSubarraySumUtil(A, B, n, m):

    # set max_so_far to INT_MIN
    max_so_far,curr_max = -sys.maxsize - 1,0

    for i in range(n):

        # if the element is present in B,
        # set current max to 0 and move to
        # the next element
        if (binary_search(B, m, A[i])):
            curr_max = 0
            continue

        # Proceed as in Kadane's Algorithm
        curr_max = max(A[i], curr_max + A[i])
        max_so_far = max(max_so_far, curr_max)

    return max_so_far

# Wrapper for findMaxSubarraySumUtil()
def findMaxSubarraySum(A,B,n,m):

    # sort array B to apply Binary Search
    B.sort()

    maxSubarraySum = findMaxSubarraySumUtil(A, B, n, m)

    # This case will occur when all elements
    # of A are present in B, thus no subarray
    # can be formed
    if (maxSubarraySum == -sys.maxsize - 1):
        print("Maximum subarray sum cant be found")
    else:
        print(f"The Maximum subarray sum = {maxSubarraySum}")

# Driver Code
A = [ 3, 4, 5, -4, 6 ]
B = [ 1, 8, 5 ]

n = len(A)
m = len(B)

# Function call
findMaxSubarraySum(A, B, n, m)

# This code is contributed by shinjanpatra

C#

// C# Program to find max subarray
// sum excluding some elements
using System;

class GFG {

    // Utility function for findMaxSubarraySum()
    // with the following parameters
    // A => Array A,
    // B => Array B,
    // n => Number of elements in Array A,
    // m => Number of elements in Array B
    static int findMaxSubarraySumUtil(int []A, int []B,
                                      int n, int m)
    {

        // set max_so_far to INT_MIN
        int max_so_far = int.MinValue, curr_max = 0;

        for (int i = 0; i < n; i++)
        {
            // if the element is present in B,
            // set current max to 0 and move to
            // the next element
            if (Array.BinarySearch(B, A[i]) >= 0)
            {
                curr_max = 0;
                continue;
            }

            // Proceed as in Kadane's Algorithm
            curr_max = Math.Max(A[i], curr_max + A[i]);
            max_so_far = Math.Max(max_so_far, curr_max);
        }
        return max_so_far;
    }

    // Wrapper for findMaxSubarraySumUtil()
    static void findMaxSubarraySum(int []A, int []B, int n,
                                   int m)
    {
        // sort array B to apply Binary Search
        Array.Sort(B);

        int maxSubarraySum
            = findMaxSubarraySumUtil(A, B, n, m);

        // This case will occur when all elements
        // of A are present in B, thus no subarray
        // can be formed
        if (maxSubarraySum == int.MinValue)
        {
            Console.WriteLine(
                "Maximum subarray sum cant be found");
        }
        else
        {
            Console.WriteLine("The Maximum subarray sum = "
                               + maxSubarraySum);
        }
    }

    // Driver Code
    public static void Main(params string[] args)
    {
        int []A = { 3, 4, 5, -4, 6 };
        int []B = { 1, 8, 5 };

        int n = A.Length;
        int m = B.Length;

        // Function call
        findMaxSubarraySum(A, B, n, m);
    }
}

// This code is contributed by pratham76.

Javascript

<script>

// JavaScript Program to find max subarray
// sum excluding some elements

// Utility function for findMaxSubarraySum()
// with the following parameters
// A => Array A,
// B => Array B,
// n => Number of elements in Array A,
// m => Number of elements in Array B
function binary_search(B, m, target)
{

    let start = 0, end = m - 1;

    // Iterate while start not meets end
    while (start <= end)
    {

        // Find the mid index
        let mid = Math.floor((start + end)/2);

        // If element is present at mid, return True
        if (B[mid] === target) return true;

        // Else look in left or right half accordingly
        else if (B[mid] < target)
             start = mid + 1;
        else
             end = mid - 1;
    }

    return false;
}

function findMaxSubarraySumUtil(A, B, n, m)
{

    // set max_so_far to INT_MIN
    let max_so_far = Number.MIN_VALUE, curr_max = 0;

    for (let i = 0; i < n; i++) {

        // if the element is present in B,
        // set current max to 0 and move to
        // the next element
        if (binary_search(B, m, A[i])) {
            curr_max = 0;
            continue;
        }

        // Proceed as in Kadane's Algorithm
        curr_max = Math.max(A[i], curr_max + A[i]);
        max_so_far = Math.max(max_so_far, curr_max);
    }
    return max_so_far;
}

// Wrapper for findMaxSubarraySumUtil()
function findMaxSubarraySum(A,B,n,m)
{
    // sort array B to apply Binary Search
    B.sort();

    let maxSubarraySum = findMaxSubarraySumUtil(A, B, n, m);

    // This case will occur when all elements
    // of A are present in B, thus no subarray
    // can be formed
    if (maxSubarraySum == Number.MIN_VALUE) {
        document.write("Maximum subarray sum cant be found","</br>");
    }
    else {
        document.write(`The Maximum subarray sum = ${maxSubarraySum}`,"</br>");
    }
}

// Driver Code
let A = [ 3, 4, 5, -4, 6 ];
let B = [ 1, 8, 5 ];

let n = A.length;
let m = B.length;

// Function call
findMaxSubarraySum(A, B, n, m);

// This code is contributed by shinjanpatra

</script>

Output

The Maximum subarray sum = 7

Time Complexity: O(nlog(m) + mlog(m)) or O((n + m)log(m)). 
Note: The mlog(m) factor is due to sorting the array B.
Auxiliary Space: O(1)

Method 3: O(max(n,m)) approach)

The main idea behind this approach is save B array in a map which will help you to check if A[i] is present in B or not.

Below is the implementation of the above approach:

C++

// C++ Program implementation of the
// above idea

#include<bits/stdc++.h>
using namespace std;

// Function to calculate the max sum of contiguous
// subarray of B whose elements are not present in A
int findMaxSubarraySum(vector<int> A,vector<int> B)
{
    unordered_map<int,int> m;

    // mark all the elements present in B
    for(int i=0;i<B.size();i++)
    {
        m[B[i]]=1;
    }

    // initialize max_so_far with INT_MIN
    int max_so_far=INT_MIN;
    int currmax=0;

    // traverse the array A
    for(int i=0;i<A.size();i++)
    {
        if(currmax<0 || m[A[i]]==1)
        {
            currmax=0;
            continue;
        }

        currmax=max(A[i],A[i]+currmax);

        // if current max is greater than
        // max so far then update max so far
        if(max_so_far<currmax)
        {
            max_so_far=currmax;
        }
    }
    return max_so_far;
}

// Driver Code
int main()
{
    vector<int> a = { 3, 4, 5, -4, 6 };
    vector<int> b = { 1, 8, 5 };

    // Function call
    cout << findMaxSubarraySum(a,b);
    return 0;
}

//This code is contributed by G.Vivek

Java

// Java Program implementation of the
// above idea
import java.util.*;
class GFG
{

  // Function to calculate the max sum of contiguous
  // subarray of B whose elements are not present in A
  static int findMaxSubarraySum(int A[], int B[])
  {
    HashMap<Integer, Integer> m = new HashMap<>();

    // mark all the elements present in B
    for(int i = 0; i < B.length; i++)
    {
      m.put(B[i], 1);
    }

    // initialize max_so_far with INT_MIN
    int max_so_far = Integer.MIN_VALUE;
    int currmax = 0;

    // traverse the array A
    for(int i = 0; i < A.length; i++)
    {

      if(currmax < 0 || (m.containsKey(A[i]) && m.get(A[i]) == 1))
      {
        currmax = 0;
        continue;
      }

      currmax = Math.max(A[i], A[i] + currmax);

      // if current max is greater than
      // max so far then update max so far
      if(max_so_far < currmax)
      {
        max_so_far = currmax;
      }
    }
    return max_so_far;
  }

  // Driver code
  public static void main(String[] args)
  {
    int a[] = { 3, 4, 5, -4, 6 };
    int b[] = { 1, 8, 5 };

    // Function call
    System.out.println(findMaxSubarraySum(a, b));
  }
}

// This code is contributed by divyesh072019.

Python3

# Python3 program implementation of the
# above idea
import sys

# Function to calculate the max sum of
# contiguous subarray of B whose elements
# are not present in A
def findMaxSubarraySum(A, B):

    m = dict()

    # Mark all the elements present in B
    for i in range(len(B)):
        if B[i] not in m:
            m[B[i]] = 0

        m[B[i]] = 1

    # Initialize max_so_far with INT_MIN
    max_so_far = -sys.maxsize - 1
    currmax = 0

    # Traverse the array A
    for i in range(len(A)):
        if (currmax < 0 or (A[i] in m and m[A[i]] == 1)):
            currmax = 0
            continue

        currmax = max(A[i], A[i] + currmax)

        # If current max is greater than
        # max so far then update max so far
        if (max_so_far<currmax):
            max_so_far = currmax

    return max_so_far

# Driver Code
if __name__=='__main__':

    a = [ 3, 4, 5, -4, 6 ]
    b = [ 1, 8, 5 ]

    # Function call
    print(findMaxSubarraySum(a, b))

# This code is contributed by rutvik_56

C#

// C# Program implementation of the
// above idea
using System;
using System.Collections.Generic;
class GFG {

  // Function to calculate the max sum of contiguous
  // subarray of B whose elements are not present in A
  static int findMaxSubarraySum(int[] A, int[] B)
  {
    Dictionary<int, int> m = new Dictionary<int, int>();

    // mark all the elements present in B
    for(int i = 0; i < B.Length; i++)
    {
      m[B[i]] = 1;
    }

    // initialize max_so_far with INT_MIN
    int max_so_far = Int32.MinValue;
    int currmax = 0;

    // traverse the array A
    for(int i = 0; i < A.Length; i++)
    {

      if(currmax<0 || (m.ContainsKey(A[i]) && m[A[i]] == 1))
      {
        currmax = 0;
        continue;
      }

      currmax = Math.Max(A[i],A[i]+currmax);

      // if current max is greater than
      // max so far then update max so far
      if(max_so_far<currmax)
      {
        max_so_far = currmax;
      }
    }
    return max_so_far;
  }

  // Driver code.
  static void Main() {
    int[] a = { 3, 4, 5, -4, 6 };
    int[] b = { 1, 8, 5 };

    // Function call
    Console.WriteLine(findMaxSubarraySum(a,b));
  }
}

// This code is contributed by divyeshrabadiya07.

Javascript

<script>

// JavaScript program implementation of the
// above idea

// Function to calculate the max sum of
// contiguous subarray of B whose elements
// are not present in A
function findMaxSubarraySum(A, B){

    let m = new Map()

    // Mark all the elements present in B
    for(let i=0;i<A.length;i++){
        if(m.has(B[i]))
            m.set(B[i],0)

        m.set(B[i],1)
    }

    // Initialize max_so_far with INT_MIN
    max_so_far = Number.MIN_VALUE
    currmax = 0

    // Traverse the array A
    for(let i=0;i<A.length;i++){
        if (currmax < 0 || (m.has(A[i]) && m.get(A[i]) == 1)){
            currmax = 0
            continue
        }

        currmax = Math.max(A[i], A[i] + currmax)

        // If current max is greater than
        // max so far then update max so far
        if (max_so_far<currmax)
            max_so_far = currmax
    }
    return max_so_far
}

// Driver Code

let a = [ 3, 4, 5, -4, 6 ]
let b = [ 1, 8, 5 ]

// Function call
document.write(findMaxSubarraySum(a, b),"</br>")

// This code is contributed by shinjanpatra

</script>

Output

7

Time Complexity: O(max(n,m))
Auxiliary Space: O(n)