数组四等分

        对于一个长度为N的整型数组A， 数组里所有的数都是正整数，对于两个满足0<=X <= Y <N的整数，A[X], A[X+1] … A[Y]构成A的一个切片，记作(X, Y)。
用三个下标 m1, m2, m3下标满足条件 0 < m1, m1 + 1 < m2, m2 +1 < m3 < N – 1。
可以把这个整型数组分成(0, m1-1), (m1+1, m2-1), (m2+1, m3-1), (m3+1, N-1) 四个切片。如果这四个切片中的整数求和相等，称作“四等分”。
编写一个函数，求一个给定的整型数组是否可以四等分，如果可以，返回一个布尔类型的true，如果不可以返回一个布尔类型的false。
限制条件： 数组A最多有1,000,000项，数组中的整数取值范围介于-1,000,000到1,000,000之间。
要求： 函数的计算复杂度为O(N)，使用的额外存储空间（除了输入的数组之外）最多为O(N)。
例子：
对于数组A=[2, 5, 1, 1, 1, 1, 4, 1, 7, 3, 7] 存在下标 2, 7, 9使得数组分成四个分片[2, 5], [1, 1, 1, 4], [7], [7]，这三个分片内整数之和相等，所以对于这个数组，函数应该返回true。

对于数组 A=[10, 2, 11, 13, 1, 1, 1, 1, 1]， 找不到能把数组四等分的下标，所以函数应该返回false。

第一次写博客，这是阿里上机笔试，仅作为交流用，切勿抄袭。对于这道题，本人思考一个小时，想用O(n)算法解决，但最后还是仅仅做到O(nlogn)的一个算法，哎，只能服了自己的智商，如果有O(n)时间的算法可以解决此问题，还请不吝赐教

核心思想：左右累加，标记前行。八个字概括这个算法，两端累加是基础，但是两端累加和相等时并不一定是四分点，所以只能标记之后再往后判断

public static boolean attemp(int[] A,int m1,int m3,int target) {
       int left_A_sum = A[m1+1];
       int right_A_sum = A[m3-1];
       int low = m1;
       int high =m3;
       for(low+=1,high-=1; low<high; ){
      if(low+1 == high) break;//不可划分
      if(left_A_sum == target && left_A_sum == right_A_sum && low+1 == high-1)//正确划分
      return true;
      if(left_A_sum == target && left_A_sum == right_A_sum && low+1 != high-1)//错误划分
      return false;
      if(left_A_sum > target) break;//超出判断范围
      if(left_A_sum < target){//防止 left_A_sum == right_A_sum 死循环
      left_A_sum += A[low+1];
      low++;
      }
      if(left_A_sum < right_A_sum){//正常判断
      left_A_sum += A[low+1];
      low++;
      }else if(right_A_sum < left_A_sum){
      right_A_sum += A[high-1];
      high--;
      }   
       }
       return false;
}
 static boolean resolve(int[] A) {
      //扣掉三个值:m1,m2,m3得到四等分，所以首先两头的必是从边界开始累加的
 boolean result = false;
      int A_length = A.length;
      int left_A_sum = A[0];
      int right_A_sum = A[A_length - 1];
      int low = 0, high= A_length-1;
      int m1=-1,m2=-1,m3=-1;
      while(low<high){
      if(left_A_sum == right_A_sum){
      //进行一次划分尝试
      if(low+1 == high-1)//不可划分表示不可四等分
      return result;
      else if(attemp(A,low+1,high-1,left_A_sum)){//划分成功
      System.out.println("m1:"+(low+1)+"---"+"m3:"+(high-1)+"划分正确");
      return true;
      }else{
      //划分失败，则用m1标记失败处，往后查找可行划分元
      m1 = low + 1;
      m3 = high - 1;
      left_A_sum += A[low + 1];
      right_A_sum += A[high - 1];
      low++;
      high--;
      System.out.println("m1:"+m1+"---"+"m3:"+m3+"划分错误");
      continue;
      }
      }
      
      if(left_A_sum < right_A_sum){
      left_A_sum += A[low+1];
      low++;
      }else if(right_A_sum < left_A_sum){
      right_A_sum += A[high-1];
      high--;
      }
      }
      return result;


   }