LeetCode刷题之1508. 子数组和排序后的区间和

给你一个数组 nums ，它包含 n 个正整数。你需要计算所有非空连续子数组的和，并将它们按升序排序，得到一个新的包含 n * (n + 1) / 2 个数字的数组。

请你返回在新数组中下标为 left 到 right （下标从 1 开始）的所有数字和（包括左右端点）。由于答案可能很大，请你将它对 10^9 + 7 取模后返回。

示例 1：

输入：nums = [1,2,3,4], n = 4, left = 1, right = 5
输出：13
解释：所有的子数组和为 1, 3, 6, 10, 2, 5, 9, 3, 7, 4 。将它们升序排序后，我们得到新的数组 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 1 到 ri = 5 的和为 1 + 2 + 3 + 3 + 4 = 13 。

示例 2：

输入：nums = [1,2,3,4], n = 4, left = 3, right = 4
输出：6
解释：给定数组与示例 1 一样，所以新数组为 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 3 到 ri = 4 的和为 3 + 3 = 6 。

最直观的做法就是求出所有非空连续子数组的和，然后排序，直接暴力。

一、暴力解法

暴力也分两种一种通过前缀和，另外一种就是双重for循环。只写后一种，代码如下：

class Solution {
    public int rangeSum(int[] nums, int n, int left, int right) {
        int len=n*(n+1)/2;

        int []sum=new int[len];
        int index=0;
       for(int i=0;i<nums.length;i++){
           int sum1=0;//记录非空子数组的和
           for(int j=i;j<nums.length;j++){
              sum1+=nums[j];
              sum1=sum1;
              sum[index++]=sum1;
           }
       }
        Arrays.sort(sum);
        int t=0;
        for(int i=left-1;i<right;i++){
            t+=sum[i];
            t%=1000000007;
        }

        return t;
    }
}

二、二分解法

二分也是需要通过前缀和来求解，left对应的某个连续非空子数组的和，一定在前缀和数组的第一个元素到最后一个元素之间。这样的话我们就可通过二分来找left此时对应连续非空子数组和，mid左边的非空连续子数组的个数如果小于left说明mid值太小，可以让L=mid+1,如果mid>=left,说明此时mid左边的非空连续子数组的个数已经超过了left，right=mid;通过不断的找最终会停在left对应下的非空连续子数组的和，但此时的值并不是真正left，因为存在重复的非空连续子数组的和，所以在这不能直接计算。获取之后，我们只需要求出left-1对应的非空连续子数组的总和 和right对应的非空连续子数组的总和 让他们想减就是中间的非空连续子数组的总和。

class Solution {
    final static int MOD = (int)1e9+7;
    public int rangeSum(int[] nums, int n, int left, int right) {
       int []prefix=new int[nums.length+1];

       prefix[0]=0;
       for(int i=0;i<nums.length;i++){
           prefix[i+1]=nums[i]+prefix[i];//前缀和
       }
      
       return getSum(prefix,right)-getSum(prefix,left-1);
        
    }
    //求k前面所有数的和
    public int getSum(int[] prefix,int k){
        
        int num=getKth(prefix,k);

        int count=0;

        int sum=0;

        for(int i=0;i<prefix.length-1;i++){
            int j=i+1;
            while(j < prefix.length && prefix[j]-prefix[i] < num){
                sum=(sum+prefix[j]-prefix[i])%1000000007;
                j++;
            }
            j--;
            count+=j-i;
        }
        
        sum=(sum+(k-count)*num)%1000000007;

        return sum;
    }
    //求最接近left下标的前缀和
    public int getKth(int[] prefix,int k){

          int left=prefix[0],right=prefix[prefix.length-1];

          while(left<right){

            int mid=((right-left)>>1)+left;

            if(getCount(mid,prefix)>=k){
                right=mid;
            }else{
                left=mid+1;
            }
        }

        return left;
    }
    //求sum前面有几个数
    public int getCount(int sum,int[] prefix){
        int count=0;

        for(int i=0,j=1;i<prefix.length-1;i++){
            while(j < prefix.length && prefix[j]-prefix[i] <= sum){
                j++;
            }
            j--;
            count+=j-i;
        }
        return count;

    }
}

当然上面的代码仍然可以优化，减少时间复杂度，我们可以在求非空连续子数组的总和时，可以利用前缀和的特点来求出，我们可对前缀和数组再次求前缀和，举个例子，假如我们要求j到i的非空连续子数组的总和，prefix[i+1]-[i]+prefix[i+2]-prefix[i]....+prefix[j]-prefix[i] 可以以推导出prefix[i+1]+prefix[i+2]+...prefix[j]-(j-i)*pre[i],前半部分不就是prefixfix[j]-prefixfix[i]这样我们就可以一次求出和了。下面是代码：

class Solution {
    final static int MOD = (int)1e9+7;
    public int rangeSum(int[] nums, int n, int left, int right) {
       int []prefix=new int[nums.length+1];

       prefix[0]=0;
       for(int i=0;i<nums.length;i++){
           prefix[i+1]=nums[i]+prefix[i];//前缀和数组
       }
       
       int[] prefixfix=new int[prefix.length];
       prefixfix[0]=0;
        for(int i=0;i<nums.length;i++){
           prefixfix[i+1]=prefixfix[i]+prefix[i+1];前缀和的前缀和数组
       }

       return getSum(prefix,prefixfix,right)-getSum(prefix,prefixfix,left-1);
        
    }
    //求k前面所有数的和
    public int getSum(int[] prefix,int[] prefixfix,int k){
        
        int num=getKth(prefix,k);

        int count=0;

        int sum=0;

        for(int i=0,j=1;i<prefix.length-1;i++){
            while(j < prefix.length && prefix[j]-prefix[i] < num){
                j++;
            }
            j--;
            sum = (sum + prefixfix[j] - prefixfix[i] - prefix[i] * (j - i))%1000000007;
            count+=j-i;
        }
        
        sum=(sum+(k-count)*num)%1000000007;//因为剩余的有重复的需看下k-count是否还有数有就加上没有就时0呗

        return sum;
    }
    //求最接近left下标的前缀和
    public int getKth(int[] prefix,int k){

          int left=prefix[0],right=prefix[prefix.length-1];

          while(left<right){

            int mid=((right-left)>>1)+left;

            if(getCount(mid,prefix)>=k){
                right=mid;
            }else{
                left=mid+1;
            }
        }

        return left;
    }
    //求sum前面有几个数
    public int getCount(int sum,int[] prefix){
        int count=0;

        for(int i=0,j=1;i<prefix.length-1;i++){
            while(j < prefix.length && prefix[j]-prefix[i] <= sum){
                j++;
            }
            j--;
            count+=j-i;
        }
        return count;

    }
}