这道看上去不难，其实有不少坑。
笔者刚开始把打算用我最爱的双指针，L, R,如果L左边的sum 和 L右边的sum相等，那我在 L，R之间找一找能不能解决也找到两对和他们的sum相等的。 可提交之后发现坑了。
如果LR， 两sum不相等， 那怎么弄？ 因为这些个数字可以是负数，所以即使如果 L这边的值大，也不一定要移动R指针。
。。。。所以笔者就陷入了两难。

然后就尝试DFS吧。列举各种可能，然后剪枝， 反正也就4层DFS。 其实也就三层。大量剪枝后效果也不是很差。下面是DFS的做法。这个最坏是ON^3的写法。实际运行起来没那么差因为剪枝
这个做法写的挺丑的 主要DFS分各种情况，不够美观 。

    public boolean splitArray(int[] nums) {
        int N = nums.length;
        Map<Integer, Set<Integer>> prefixMap = new HashMap<>();
        int[] prefixSum = new int[N];
        int preSum = 0;
        for (int i = 0; i < N; i++) {
            preSum += nums[i];
            prefixSum[i] = preSum;
            prefixMap.putIfAbsent(preSum, new HashSet<>());
            prefixMap.get(preSum).add(i);
        }
        
        return dfs(nums, 0, 0, 0, prefixSum, prefixMap);
    }
    private boolean dfs(int[] nums, int index, int depth, int sum, int[] prefixSum, Map<Integer, Set<Integer>> prefixMap) {
        if (index > nums.length - 1) return false;
        if (depth == 3) { //第四层，直接判断退出
            return (sum == prefixSum[prefixSum.length - 1] - prefixSum[index - 1]);
        }
        if (depth == 0) { // 第一层，枚举所有可能 
            for (int i = index; i < nums.length; i++) {
                if (i != index && nums[i] == 0) continue; // 对于第二个0就不要算了。
                if (depth == 0 || prefixSum[i] - prefixSum[index - 1] == sum) {
                    if (dfs(nums, i + 2, depth + 1, depth == 0 ? prefixSum[i] : sum,  prefixSum, prefixMap)) return true;
                }
            }
            return false;
        }
        // 第二层第三层， 利用prefixMap大量剪枝
        if (prefixMap.get(sum + prefixSum[index - 1]) == null) return false;
        for (int candidate : prefixMap.get(sum + prefixSum[index - 1]) ) {
            if (candidate >= index & candidate + 2 < nums.length) {
                if (dfs(nums, candidate + 2, depth + 1, sum, prefixSum, prefixMap)) return true;;
            }
        }
        return false;
    }

下面讨论下看来的别人的做法。
leetcode上高票答案是sweep中间那个档板，然后sweep左边看能不能分成相等的两半，如果能，就把它放在hashset里；然后sweep右边那一半，能不能分成相等两半，如果能看看和左边有没有正好相同的配对。这个想法很赞。时间复杂度来算一下， O (N * ( N + N) ) = O(N^2)

    public boolean splitArray(int[] nums) {
        int N = nums.length;
        int[] prefixSum = new int[N];
        for (int i = 0; i < N; i++) {
            prefixSum[i] = nums[i] + (i > 0 ? prefixSum[i - 1] : 0);
        }
        int m = 3;
        while (m + 3 < N) {
            Set<Integer> set = new HashSet<>();
            int i = 1;
            while (i + 1 < m) {
                int a = prefixSum[i - 1];
                int b = prefixSum[m - 1] - prefixSum[i];
                if (a == b ) set.add(a);
                i++;
            }
            i = m + 2;
            while (i + 1 < N) {
                int a = prefixSum[i - 1] - prefixSum[m];
                int b = prefixSum[N - 1] - prefixSum[i];
                if ( a == b && set.contains(a)) return true;
                i++;
            }
            m++;
        }
        return false;
    }