Maximum Subarray sum of A[] by adding any element of B[] at any end

// Java code to implement the approach
import java.io.*;
class GFG {

  // Function to find the maximum possible sum
  static int maxSum(int[] a, int[] b, int n, int m)
  {
    int mx1 = 0, mx2 = 0;

    // Function to find the max subarray sum
    for (int i = 0, tmp = 0; i < n; i++) {
      tmp += a[i];
      if (tmp < 0) {
        tmp = 0;
      }
      else {
        mx1 = Math.max(mx1, tmp);
      }
    }

    // Function to find the maximum subarray sum
    // starting from the start
    for (int i = 0, tmp = 0; i < n; i++) {
      tmp += a[i];
      mx2 = Math.max(mx2, tmp);
    }

    // Function to find the maximum subarray sum
    // ending at the end
    for (int i = n - 1, tmp = 0; i >= 0; i--) {
      tmp += a[i];
      mx2 = Math.max(mx2, tmp);
    }

    int ans = 0;

    // Sum of the positive elements of B[]
    for (int i = 0; i < m; i++) {
      if (b[i] > 0)
        ans += b[i];
    }

    // Maximum sum when positive elements are added
    // to the start or end and the subarray
    // starts from the start or finishes at the end
    ans += mx2;

    // Return the maximum sum
    // among the above three cases
    return Math.max(ans, mx1);
  }

  public static void main(String[] args)
  {
    int[] A = { 72, 23, -56, 80 };
    int[] B = { 50, 10 };
    int N = A.length;
    int M = B.length;

    // Function call
    System.out.print(maxSum(A, B, N, M));
  }
}

// This code is contributed by lokeshmvs21.

import java.util.*;

public class Main {
    public static int maxSubArraySum(List<Integer> arr)
    {
        int maxSum = Integer.MIN_VALUE;
        int currentSum = 0;
        for (int num : arr) {
            currentSum = Math.max(num, currentSum + num);
            maxSum = Math.max(maxSum, currentSum);
        }
        return maxSum;
    }

    public static int maxSubarraySum(int N, List<Integer> A,
                                     int M, List<Integer> B)
    {
        int maxSum = Integer.MIN_VALUE;

        // Calculate max subarray sum of A
        int maxSumA = maxSubArraySum(A);

        // Initialize left and right pointers
        int left = 0;
        int right = N - 1;

        // Condition 1: Append all positive elements of B[]
        // to front of A[] and negative to back of A[]
        while (!B.isEmpty()) {
            int front = B.get(0);
            B.remove(0);

            if (front >= 0) {
                A.add(0, front);
            }
            else {
                A.add(front);
            }

            maxSum = Math.max(maxSum, maxSubArraySum(A));
        }

        // Reset A to its original state
        A.clear();
        for (int i = 0; i < N; i++) {
            A.add(0);
        }

        // Condition 2: Append all positive elements of B[]
        // to back of A[] and negative to front of A[]
        while (!B.isEmpty()) {
            int back = B.get(B.size() - 1);
            B.remove(B.size() - 1);

            if (back >= 0) {
                A.add(back);
            }
            else {
                A.add(0, back);
            }

            maxSum = Math.max(maxSum, maxSubArraySum(A));
        }

        return Math.max(maxSum, maxSumA);
    }

    public static void main(String[] args)
    {
        int N = 4;
        // I have used List here .You can use an Array of
        // your choice.
        List<Integer> A = new ArrayList<>(
            Arrays.asList(72, 23, -56, 80));
        int M = 2;
        List<Integer> B
            = new ArrayList<>(Arrays.asList(50, 10));

        System.out.println(
            maxSubarraySum(N, A, M, B)); // Output: 179
    }
}