前缀和/差分专题

板子：

（占坑）

======前缀和======

Leetcode 238. 除自身以外数组的乘积

优化前：使用前后缀数组记录

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> pre(n, 1), suf(n, 1), ans(n, 0);
        for(int i = 0; i < n; i ++)
            pre[i] = (i==0?1:pre[i - 1]) * nums[i];
        for(int i = n - 1; i >= 0; i --)
            suf[i] = (i==(n - 1)? 1 : suf[i + 1]) * nums[i];
        for(int i = 0; i < n; i ++)
            ans[i] = (i==0?1:pre[i - 1])  * (i==(n-1)?1:suf[i + 1]);
        return ans;
    }
};

优化后：

先计算 pre，然后一边计算 suf，一边把 suf直接乘到 pre[i] 中。最后返回 pre。(注意：suf是从1开始累乘的)

题目说「输出数组不被视为额外空间」，所以该做法的空间复杂度为 O(1)。此外，这种做法比上面少遍历了一次。

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> pre(n, 1);
        // 计算出前缀和数组
        for(int i = 1; i < n; i ++)
            pre[i] = pre[i - 1] * nums[i - 1];
        // 针对前缀和数组补上后缀计算部分即可
        int suf = 1;
        for(int i = n - 1; i >= 0; i --){
            pre[i] = pre[i] * suf;
            suf *= nums[i];
        }
        return pre;
    }
};

Leetcode 3148. 矩阵中的最大得分

核心：

• 模拟过程，发现只与起点和终点的值相关，联想到重力势能
• 可以维护一个二维的前缀最小值，当前值grid(i, j) - 当前矩阵除了当前当前元素的min（提前维护好了）

  

class Solution {
public:
    int maxScore(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size(), ans = INT_MIN;
        vector<vector<int>> pre(n + 1, vector<int>(m + 1, INT_MAX));    // 这边要初始化为max(因为要维护的是前缀的最小值)
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++){
                int t = min(pre[i + 1][j], pre[i][j + 1]);
                ans = max(ans, grid[i][j] - t);
                pre[i + 1][j + 1] = min(t, grid[i][j]);
            }
        return ans;
    }
};                                                               

在实现过程中，由于数组下标是从0开始的，为了防止数组越界，使用pre[i + 1][j + 1]表示矩阵[0,i][0,j]的min.

======差分======

 Leetcode 1450. 在既定时间做作业的学生人数

本题可以简单做，但是如果是1e5的查询，那就得差分。 

class Solution {
public:
    const static int N = 1e5 + 10;
    int a[N];
    void insert(int l, int r){
        a[l] += 1, a[r + 1] -= 1;
    }
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        memset(a, 0, sizeof(a));
        int n = startTime.size();
        int maxt = 0;
        int res = 0;
        // 差分数组预处理出来
        for(int i = 0; i < n; i ++){
            int st = startTime[i], ed = endTime[i];
            maxt = max(maxt, ed);
            insert(st, ed);
        }
        for(int i = 1; i <= maxt + 1; i ++) a[i] += a[i - 1];   // 这边边界是maxt + 1
        return a[queryTime];
    }
};

二分方法：sort从集合的角度思考