算法
    可以用动态规划的思想去看，
    设 S(i) 为以第 i 个元素结尾的和小于 N 的最长连续数组
    设 len(i) 为 S(i) 的长度
    设 sum(i) 为 S(i) 的和

    1. 边界：
      • len(0) = arr[0] < N ? 1 : 0
      • sum(0) = arr[0] （对于不可取的数（比 N 大）我们也把和记上）
    2. 当计算 S(i) 时，如果 arr[i] >= N，那么舍弃
    3. 否则
      1. 将 arr[i] 加入 S(i) 中（目前 len(i) 为 1, sum(i) 为 arr[i]）
      2. 不停归并 S(i) 左边相邻的 S(i-len(i)) ，直到 sum(i) 不再小于 N
        1. 这里需要注意对于一些比 N 大的项原来不可取，现在也有可能取到
      3. 最后从 S(i) 最左的元素往右筛除，缩小数组直到总和小于 N

    最后根据最长的 len 返回数组即可

    1. public class LongestArr {
    2.     int longestArr(int[] arr, int N){
    3.         int[] len=new int[arr.length];
    4.         int[] sum=new int[arr.length];
    5.         for(int i=1;i<arr.length; i++){
    6.             if(arr[i] >N){
    7.                 len[i]=0;
    8.                 sum[i] = arr[i];
    9.             }else {
    10.                 len[i]=1;
    11.                 sum[i]=arr[i];
    13.                 for(int j=i;j>=0&&sum[i]<N;j=j-len[i]){
    14.                     sum[i]+=sum[j];
    15.                     len[i]+=len[j]|1;
    16.                 }
    18.                 for(int j=i+1-len[i]; j<i && sum[i]>=N; j++){
    19.                     len[i]-=1;
    20.                     sum[i]-=arr[j];
    21.                 }
    22.             }
    23.         }
    25.         int max = 0;
    26.         for(int i=0; i<len.length; i++){
    27.             max=Math.max(len[i], max);
    28.         }
    29.         return max;
    30.     }
    32.     public static void main(String[] args) {
    33.         LongestArr longestArr = new LongestArr();
    34.         int[] arr = new int[]{-1,1,1,9};
    35.         int N=10;
    36.         System.out.println(longestArr.longestArr(arr, N)); //3
    38.         int[] arr2 = new int[]{-1,1,1,9,-1};
    39.         System.out.println(longestArr.longestArr(arr2, N)); //5
    40.     }
    41. }