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 2Input : 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 Ai is present in B, all subarrays in A from 0 to (i – 1) cannot be extended further as, the ith 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++ 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 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. |
# 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# 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 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) ?> |
<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> |
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++ 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 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 |
# 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# 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. |
<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> |
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++ 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 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 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# 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. |
<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> |
7
Time Complexity: O(max(n,m))
Auxiliary Space: O(n)