Clarification of Answer... find the max possible two equal sum in a SET

I think thinking how this solution relates to the single subset problem might be misleading for you. Here we are concerned with a maximum achievable sum, and what's more, we need to distinguish between two disjoint sets of numbers as we traverse. Clearly tracking specific combinations would be too expensive.

Looking at the difference between sets A and B, we can say:

A - B = d
A = d + B

Clearly, we want the highest sum when d = 0. How do we know that sum? It's (A + B) / 2!

For the transition in the dynamic program, we'd like to know if it's better to place the current element in A, B or neither. This is achieved like this:

e <- current element
d <- difference between A and B

(1) add e to A -> d + e

why? 
A = d + B
(A + e) = d + e + B

(2) add e to B -> d - e

why? 
A = d + B
A = d - e + (B + e)

(3) don't use e -> that's simply
  what we already have stored for d

Let's look at Peter de Rivas' code for the transition:

# update a copy of our map, so
# we can reference previous values,
# while assigning new values
D2=D.copy()

# d is A - B
# s is A + B
for d,s in D.items():

  # a new sum that includes element a
  # we haven't decided if a 
  # will be in A or B
  s2 = s + a

  # d2 will take on each value here
  # in turn, once d - a (adding a to B),
  # and once d + a (adding a to A)
  for d2 in [d-a, d+a]:

    # The main transition:
    # the two new differences,
    # (d-a) and (d+a) as keys in
    # our map get the highest sum
    # seen so far, either (1) the
    # new sum, s2, or (2) what we
    # already stored (meaning `a`
    # will be excluded here)
    # so all three possibilities
    # are covered.
    D2[abs(d2)] = max(D2[abs(d2)], s2)

In the end we have stored the highest A + B seen for d = 0, where the elements in A and B form disjoint sets. Return (A + B) / 2.

Try this dp approch : it works fine.

/*
 * 
 i/p ::

1
5
1 2 3 4 6
o/p : 8

1
4
4 10 18 22
o/p : 22


1
4
4 118 22 3
o/p : 0
 */
import java.util.Scanner;

public class TwoPipesOfMaxEqualLength {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            int[] arr = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                arr[i] = sc.nextInt();
            }
            MaxLength(arr, n);
        }
    }

    private static void MaxLength(int[] arr, int n) {

        int dp[][] = new int[1005][1005];
        int dp1[][] = new int[1005][1005];

        // initialize dp with values as 0.
        for (int i = 0; i <= 1000; i++) {
            for (int j = 0; j <= 1000; j++)
                dp[i][j] = 0;
        }

        // make (0,0) as 1.
        dp[0][0] = 1;


        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= 1000; j++) {
                for (int k = 0; k <= 1000; k++) {
                    if (j >= arr[i]) {
                        if (dp[j - arr[i]][k] == 1) {
                            dp1[j][k] = 1;## Heading ##
                        }
                    }
                    if (k >= arr[i]) {
                        if (dp[j][k - arr[i]] == 1) {
                            dp1[j][k] = 1;
                        }
                    }
                    if (dp[j][k] == 1) {
                        dp1[j][k] = 1;
                    }
                }
            }

            for (int j = 0; j <= 1000; j++) {
                for (int k = 0; k <= 1000; k++) {
                    dp[j][k] = dp1[j][k];
                    dp1[j][k] = 0;
                }
            }
        }

        int ans = 0;

        for (int i = 1; i <= 1000; i++) {
            if (dp[i][i] == 1) {
                ans = i;
            }
        }

        System.out.println(ans);

    }

}

#include <bits/stdc++.h>
using namespace std;

/*
    Brute force recursive solve.
*/

void solve(vector<int>&arr, int &ans, int p1, int p2, int idx, int mx_p){
    
    // if p1 == p2, we have a potential answer
    if(p1 == p2){
        ans = max(ans, p1);
    }
    
    //base case 1:
    if((p1>mx_p) || (p2>mx_p) || (idx >= arr.size())){
        return;
    }
    
    // leave the current element
    solve(arr, ans, p1, p2, idx+1, mx_p);

    // add the current element to p1
    solve(arr, ans, p1+arr[idx], p2, idx+1, mx_p);

    // add the current element to p2
    solve(arr, ans, p1, p2+arr[idx], idx+1, mx_p);
}

/*
    Recursive solve with memoization.
*/

int solve(vector<vector<vector<int>>>&memo, vector<int>&arr,
                                int p1, int p2, int idx, int mx_p){

    //base case 1:
    if((p1>mx_p) || (p2>mx_p) || (idx>arr.size())){
        return -1;
    }
    
    // memo'ed answer
    if(memo[p1][p2][idx]>-1){
        return memo[p1][p2][idx];
    }


    // if p1 == p2, we have a potential answer
    if(p1 == p2){
        memo[p1][p2][idx] = max(memo[p1][p2][idx], p1);
    }
    
    // leave the current element
    memo[p1][p2][idx] = max(memo[p1][p2][idx], solve(memo, arr, p1, p2, 
                           idx+1, mx_p));

    // add the current element to p1
    memo[p1][p2][idx] = max(memo[p1][p2][idx], 
                            solve(memo, arr, p1+arr[idx], p2, idx+1, mx_p));

    // add the current element to p2
    memo[p1][p2][idx] = max(memo[p1][p2][idx], 
                            solve(memo, arr, p1, p2+arr[idx], idx+1, mx_p));
                            
    return memo[p1][p2][idx];
}

int main(){
    
    vector<int>arr = {1, 2, 3, 4, 7};
    int ans = 0;
    int mx_p = 0;
    
    for(auto i:arr){
        mx_p += i;
    }
    mx_p /= 2;
    
    vector<vector<vector<int>>>memo(mx_p+1, vector<vector<int>>(mx_p+1, 
                                    vector<int>(arr.size()+1,-1)));
    ans = solve(memo, arr, 0, 0, 0, mx_p);
    ans = (ans>=0)?ans:0;
    
    // solve(arr, ans, 0, 0, 0, mx_p);
    cout << ans << endl;
    return 0;
}