排除某些元素的最大子数组总和

给定n个整数的A数组和m个整数的B数组，找到数组A的最大连续子数组总和，以使该子数组中不存在数组B的任何元素。

例子 ：

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

方法1(O(n * m)方法)：
我们可以使用Kadane算法来解决此问题。由于我们不希望数组B的任何元素成为A的任何子数组的一部分，因此我们需要对经典的Kadane算法进行一些修改。
每当我们考虑Kadane算法中的元素时，我们要么扩展当前子数组，要么开始一个新的子数组。

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

现在，在这个问题中，当我们考虑任何元素时，我们通过在数组B中进行线性搜索进行检查，如果该元素存在于B中，则将curr_max设置为零，这意味着在该索引处，我们认为到该点的所有子数组都将结束并由于无法形成其他连续数组，因此不再进一步扩展，即

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

如果数组A的当前元素不是数组B的一部分，我们继续使用Kadane算法，并跟踪max_so_far。

C++

// C++ Program to find max subarray
// sum excluding some elements
#include 
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 occour 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 occour 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 occour 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 occour 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

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

 
// 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 occour 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.

---

---

输出

The Maximum Subarray Sum = 7

时间复杂度： O(n * m)

方法2(O((n + m)* log(m))方法)
该方法背后的主要思想与方法1完全相同。该方法仅通过使用二进制搜索就可以更快地搜索数组B中数组A的元素。
注意：我们需要对数组B进行排序，以对其应用二进制搜索。

C++

// C++ Program to find max subarray
// sum excluding some elements
#include 
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 occour 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 occour 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

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

输出

The Maximum subarray sum = 7

时间复杂度： O(nlog(m)+ mlog(m))或O((n + m)log(m))。
注意：mlog(m)因子归因于对数组B的排序。

方法3： O(max(n，m))方法)

这种方法的主要思想是将B数组保存在映射中，这将帮助您检查A [i]是否存在于B中。
下面是上述方法的实现：

C++

// C++ Program implementation of the
// above idea
 
#include
using namespace std;
 
// Function to calculate the max sum of contigous
// subarray of B whose elements are not present in A
int findMaxSubarraySum(vector A,vector B)
{
    unordered_map m;
   
    // mark all the elements present in B
    for(int i=0;i a = { 3, 4, 5, -4, 6 };
    vector 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 contigous
  // subarray of B whose elements are not present in A
  static int findMaxSubarraySum(int A[], int B[])
  {
    HashMap 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
# contigous 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

C＃

// C# Program implementation of the
// above idea
using System;
using System.Collections.Generic;
class GFG {
 
  // Function to calculate the max sum of contigous
  // subarray of B whose elements are not present in A
  static int findMaxSubarraySum(int[] A, int[] B)
  {
    Dictionary m = new Dictionary(); 
 
    // 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

输出

7

时间复杂度： O(max(n，m))