Maximum Subarray Sum Excluding Certain Elements

<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>

<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>

<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>