CCF CSP 202012-2 期末预测之最佳阈值-前缀和专题

1、一维前缀和

前缀和定义

假设我们有一个字符串ABCDE，什么是这个单词的前缀，A、AB、ABC、ABCD、ABCDE就是这个单词的前缀，就是从第一个字母开始，依次往后拼接。E、ED、EDC、EDCB、EDCBA被称为这个单词的后缀。

应用

leetcode560. 和为K的子数组

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。

子数组是数组中元素的连续非空序列。

示例 1：

输入：nums = [1,1,1], k = 2
输出：2

示例 2：

输入：nums = [1,2,3], k = 3
输出：2

思路一:使用前缀和

暴力破解：使用for循环枚举子数组，并且求和，时间复杂度为O(n3)

使用前缀和，每次求出子数组的和，与k进行比较，时间复杂度为O(n2)，代码如下：

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        n = len(nums)
        result = 0
        preSum = [0] * n
        for i in range(n - 1):
            preSum[i+1] = preSum[i] + nums[i]
        for i in range(n - 1):
            for j in range(i, n - 1):
                if (preSum[j + 1] - preSum[i]) == k:
                    result += 1


        return result

思路二：使用Map+前缀和进行优化

在使用前缀和思路中，我们要求一个下标为i的子数组的和是否为k，就需要对j从-1遍历到i-1,来找到是否存在sum[i] - k = sum[j]。那么我们只要用map < 前i个元素的前缀和，出现的次数 > 把i之前的前缀和的值记录下来，判断map中是否包含sum[i] - k]即可。时间复杂度为O(n)

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        n = len(nums)
        result = 0
        preSum = [0] * n
        preSum[0] = nums[0]
        for i in range(1,n):
            preSum[i] = preSum[i - 1] + nums[i]
        print(preSum)
        m = {0:1}
        for i in range(n):
            if (preSum[i] - k) in m:
                result += m[preSum[i] - k]
            if preSum[i] in m:
                m[preSum[i]] += 1
            else: m[preSum[i]] = 1
        return result

2、二维前缀和

二维前缀和的递推公式：sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+mat[i-1][j-1];

应用

leetcode1292. 元素和小于等于阈值的正方形的最大边长

前缀和

class Solution {
    public int maxSideLength(int[][] mat, int threshold) {
        int m=mat.length;
        if(m==0)return 0;
        int n=mat[0].length;
        //第一步，计算前缀和,其中sum[i][j]表示前i行前j列的矩形元素和
        int[][] sum=new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+mat[i-1][j-1];
            }
        }

        // 枚举左上顶点，然后试边长k
        int res=0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                for(int k=1;i+k-1<=m&&j+k-1<=n;k++){
                    int tmp=sum[i+k-1][j+k-1]-sum[i-1][j+k-1]-sum[i+k-1][j-1]+sum[i-1][j-1];
                    if(tmp<=threshold){
                        res=Math.max(res,k);
                    }
                }
            }
        }
        return res;
    }
}

二分查找+前缀和

class Solution {
    public int maxSideLength(int[][] mat, int threshold) {
        int m=mat.length;
        if(m==0)return 0;
        int n=mat[0].length;
        //第一步，计算前缀和，sum[i][j]表示前i行前j列的矩形元素和
        int[][] sum=new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+mat[i-1][j-1];
            }
        }

        //二分查找最终的边长值
        //我们知道，当结果值为4时，3必满足条件，指针右移；
        // 5不满足条件，指针左移；最后指针会指向4
        int left=0,right=Math.min(m,n)+1,mid;
        while(left<right){
            mid=left+(right-left)/2;
            if(valid(sum,threshold,mid)){
                left=mid+1;
            }else{
                right=mid;
            }
        }
        return left-1; 
    }
    //判断是否满足条件
    public boolean valid(int[][] sum,int threshold,int k){
        int m=sum.length-1;
        int n=sum[0].length-1;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(i+k-1>m||j+k-1>n)continue;  
                int tmp=sum[i+k-1][j+k-1]-sum[i-1][j+k-1]-sum[i+k-1][j-1]+sum[i-1][j-1];
                if(tmp<=threshold){
                    return true;
                }                
            }
        }
        return false;
    }
}

3、期末预测之最佳阈值

解题思路

前缀和

1、前缀和是在有序数组的基础上进行的

2、在进行完排序，分别计算截止到每一个yi的正确次数

3、依次遍历每个阈值，寻找最大预测次数（最大预测次数 = 该阈值前0的个数 + 该阈值后1的个数）

4、注意遇到两个阈值相等，取最大的（通过在判断时多写一个等号即可）

m = eval(input())
yr = []
#计算1出现的总次数
ones = 0
for_ in range(m):
    yi, ri = map(int, input().split())
    yr.append([yi,ri])
    if ri == 1:
        ones = ones + 1
#对yr依据yi排序
yr.sort(key=lambda x: x[0])
oy = list(a[0] for a in yr)
ss = set()
acc_sum = [0 for _ in range(m)]
acc_sum[0] = yr[0][1]
f_t = 0
bes_res = 0
for i in range(1,m):
    acc_sum[i] = acc_sum[i - 1] + yr[i][1]
for ind, y in enumerate(oy):
    if y not in ss:
        ss.add(y)
        tem = sum[ind - 1]
        res = ind - tem + ones - tem
        if res >= bes_res:
            bes_res = res
            f_t = y
print(f_t)