Maximum Prefix Sum possible by merging two given arrays

import java.util.HashMap;
import java.util.Map;

public class Main {
  // Stores the dp states
  static Map<Tuple, Integer> dp = new HashMap<>();

  // Recursive Function to calculate the maximum
  // prefix sum obtained by merging two arrays
  static int maxPreSum(int[] a, int[] b, int x, int y)
  {
    // If subproblem is already computed
    if (dp.containsKey(new Tuple(x, y))) {
      return dp.get(new Tuple(x, y));
    }

    // If x >= N or y >= M
    if (x == a.length && y == b.length) {
      return 0;
    }

    int curr = 0;
    if (dp.containsKey(new Tuple(x, y))) {
      curr = dp.get(new Tuple(x, y));
    }

    // If x < N
    if (x == a.length) {
      curr = Math.max(
        curr, b[y] + maxPreSum(a, b, x, y + 1));
    }

    // If y<M
    else if (y == b.length) {
      curr = Math.max(
        curr, a[x] + maxPreSum(a, b, x + 1, y));
    }

    // Otherwise
    else {
      int max = Math.max(
        a[x] + maxPreSum(a, b, x + 1, y),
        b[y] + maxPreSum(a, b, x, y + 1));
      curr = Math.max(curr, max);
    }
    dp.put(new Tuple(x, y), curr);
    return dp.get(new Tuple(x, y));
  }

  // Driver code
  public static void main(String[] args)
  {
    int[] A = { 2, 1, 13, 5, 14 };
    int[] B = { -1, 4, -13 };

    System.out.println(maxPreSum(A, B, 0, 0));
  }


  // Tuple class definition
  static class Tuple {
    int x;
    int y;

    public Tuple(int x, int y)
    {
      this.x = x;
      this.y = y;
    }

    @Override public int hashCode()
    {
      final int prime = 31;
      int result = 1;
      result = prime * result + x;
      result = prime * result + y;
      return result;
    }

    @Override public boolean equals(Object obj)
    {
      if (this == obj) {
        return true;
      }
      if (obj == null) {
        return false;
      }
      if (getClass() != obj.getClass()) {
        return false;
      }
      Tuple other = (Tuple)obj;
      if (x != other.x) {
        return false;
      }
      if (y != other.y) {
        return false;
      }
      return true;
    }
  }
}

// This code is contributed by phasing17.

// Java Program to implement 
// the above approach 
import java.util.*;
class GFG {

  static int maxPresum(int [] a, int [] b) 
  { 
    
    // Stores the maximum prefix 
    // sum of the array A[] 
    int X = Math.max(a[0], 0); 

    // Traverse the array A[] 
    for (int i = 1; i < a.length; i++)
    { 
      a[i] += a[i - 1]; 
      X = Math.max(X, a[i]); 
    } 

    // Stores the maximum prefix 
    // sum of the array B[] 
    int Y = Math.max(b[0], 0); 

    // Traverse the array B[] 
    for (int i = 1; i < b.length; i++) { 
      b[i] += b[i - 1]; 
      Y = Math.max(Y, b[i]); 
    } 
    return X + Y; 
  } 

  // Driver code
  public static void main(String [] args) 
  {
    int [] A = { 2, -1, 4, -5 }; 
    int [] B = { 4, -3, 12, 4, -3 }; 
    System.out.print(maxPresum(A, B));
  }
}

// This code is contributed by ukasp.