刷题笔记15——前缀和数组+差分数组

小结：一直以为前缀和是一个乱七八糟的树，原来那个叫前缀树:)

• 前缀和适合于频繁查询原数据某个区间的累加和，所以一次性算好进行随存随取（一定要注意前边添加的0啊）
• 差分数组适合于对原始数组的某个区间进行频繁的增减(一定是完整的区间才可以)

303. 区域和检索 - 数组不可变

class NumArray {
    private int[] preSum;
    public NumArray(int[] nums) {
        int n = nums.length;
        preSum = new int[n+1];
        preSum[0] = 0;

        for(int i=1;i<n+1;i++){
            preSum[i] = preSum[i-1] + nums[i-1];
        }
    }
    
    public int sumRange(int left, int right) {
        return preSum[right+1]-preSum[left];
    }
}

304. 二维区域和检索 - 矩阵不可变

• 最初的方法是将二维区域看成是多个一维区域，每一行都计算前缀和，然后遍历行数即可

class NumMatrix {
    private int[][] preMatrix;
    public NumMatrix(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        preMatrix = new int[row][col+1];
        for(int j=0;j<row;j++){
            preMatrix[j][0] = 0;
        }

        for(int i=0;i<row;i++){
            for(int j=1;j<col+1;j++){
                preMatrix[i][j] = preMatrix[i][j-1] + matrix[i][j-1];
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        int result = 0;
        for(int i=row1;i<=row2;i++){
            result += preMatrix[i][col2+1] - preMatrix[i][col1];
        }
        return result;
    }
}

• 答案的方式不是这样子，前缀和的题难道都是提前记录，然后在sum函数中一步就得到结果这样子？？？

class NumMatrix {
    private int[][] preMatrix;
    public NumMatrix(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        preMatrix = new int[row+1][col+1];
        for(int j=0;j<row+1;j++){
            preMatrix[j][0] = 0;
            
        }
        for(int j=0;j<col+1;j++){
            preMatrix[0][j] = 0;
        }
        for(int i=1;i<row+1;i++){
            for(int j=1;j<col+1;j++){
                preMatrix[i][j] = preMatrix[i][j-1] + preMatrix[i-1][j] - preMatrix[i-1][j-1] + matrix[i-1][j-1];
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        return preMatrix[row2+1][col2+1]-preMatrix[row2+1][col1]-preMatrix[row1][col2+1] + preMatrix[row1][col1];
    }
}

差分区间的板子

// 差分数组工具类
class Difference {
    // 差分数组
    private int[] diff;
    public Difference(int[] nums){
        int n = nums.length;
        diff = new int[n];
        diff[0] = nums[0];
        for(int i=1;i<n;i++){
            diff[i] = nums[i]-nums[i-1];
        }
    }

    public void increment(int i,int j, int val){
        diff[i] += val;
        if( j+1 < diff.length){
            diff[j+1] -=val;
        }
    }

    public int[] result(){
        int[] res = new int[diff.length];
        res[0] = diff[0];
        for(int i = 1;i<diff.length;i++){
            res[i] = res[i-1] + diff[i];
        }
        return res;
    }
}



public class test2 {
    int[] getModifiedArray(int length, int[][] updates) {
        int[] nums = new int[length];
        Difference diff = new Difference(nums);
        for (int[] update : updates) {
            int left = update[0];
            int right = update[1];
            int val = update[2];
            diff.increment(left,right,val);
        }
        return diff.result();
    }

    public static void main(String[] args) {
        // Press Alt+Enter with your caret at the highlighted text to see how
        // IntelliJ IDEA suggests fixing it.
        test2 a = new test2();
        int[][] updates = new int[][]{{1,3,2},{2,4,3},{0,2,-2}};
        a.getModifiedArray(5, updates);
    }

}

这道题要付费，粘一下

1109. 航班预订统计

class Solution {
    public int[] corpFlightBookings(int[][] bookings, int n) {
        int[] nums = new int[n];
        Difference diff = new Difference(nums);
        for(int[] booking : bookings){
            int left = booking[0];
            int right = booking[1];
            int val = booking[2];
            diff.increment(left-1,right-1,val);
        }

        return diff.result();
    }
}

class Difference {
    // 差分数组
    private int[] diff;
    public Difference(int[] nums){
        int n = nums.length;
        diff = new int[n];
        diff[0] = nums[0];
        for(int i=1;i<n;i++){
            diff[i] = nums[i]-nums[i-1];
        }
    }

    public void increment(int i,int j, int val){
        if (i<diff.length){
            diff[i] += val;
        }
        if( j+1 < diff.length){
            diff[j+1] -=val;
        }
    }

    public int[] result(){
        int[] res = new int[diff.length];
        res[0] = diff[0];
        for(int i = 1;i<diff.length;i++){
            res[i] = res[i-1] + diff[i];
        }
        return res;
    }
}

1094. 拼车(做题做懵了，这里的数组值是指当前有几个位置被坐了，我一直想的是当前还剩几个位置)

class Solution {
    public boolean carPooling(int[][] trips, int capacity) {
        int[] res = new int[1001];
        Difference diff = new Difference(res);
        for(int[] trip : trips){
            int val = trip[0];
            int left = trip[1];
            int right = trip[2]-1;
            diff.increment(left,right,val);   
        }
        if(!checkCapacity(diff.result(),capacity)){
            return false;
        }
        return true;
    }

    boolean checkCapacity(int[] result,int capacity){
        for(int i=0;i<result.length;i++){
            if(result[i]>capacity){
                return false;
            }
        }
        return true;
    }
}

class Difference {
    // 差分数组
    private int[] diff;
    public Difference(int[] nums){
        int n = nums.length;
        diff = new int[n];
        diff[0] = nums[0];
        for(int i=1;i<n;i++){
            diff[i] = nums[i]-nums[i-1];
        }
    }

    public void increment(int i,int j, int val){
        if (i<diff.length){
            diff[i] += val;
        }
        if( j+1 < diff.length){
            diff[j+1] -=val;
        }
    }

    public int[] result(){
        int[] res = new int[diff.length];
        res[0] = diff[0];
        for(int i = 1;i<diff.length;i++){
            res[i] = res[i-1] + diff[i];
        }
        return res;
    }
}

• 美团的一道题，看答案是用了差分数组，记录一下
• 给定n个正整数组成的数组，求平均数正好等于 k 的最长连续子数组的长度。
  

#include <iostream>
#include <unordered_map>
#include <cmath>
#include <algorithm>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;

	vector<int> arr(n);
	for (int i = 0; i < n; i++) {
		cin >> arr[i];
	}

	// 创建diff数组
	vector<long long>  diff(n+1);
	diff[0] = 0;
	for (int i = 1; i <= n; i++) {
		diff[i] = diff[i - 1] + arr[i - 1] - k;
	}

	int max_len = -1;
	unordered_map<long long, int> mp;
	mp[0] = 0;  // 为了处理从开始的子数组
	for (int i = 1; i <= n; i++) {
		if (mp.count(diff[i])) {
			max_len = max(max_len, i - mp[diff[i]]);
		}
		else {
			mp[diff[i]] = i;  // 记录前缀和第一次出现的位置
		}
	}

	cout << (max_len == 0 ? -1 : max_len) << endl;
	return 0;
}

其实也不算是差分题，我自己理解就是有一排高低不齐的木棍，沿着平均高度裁剪，有的木棍比这个长有的比这个短，当一段连续排列的木棍，它们长的地方可以补上短木棍缺的地方的时候，那么这些木棍的平均长度是k，这道题我觉得就是先切了一刀，然后我们需要不断计算区间之间的diff和，所以可以用到前缀和，这里我觉得可以用双重循环，然后求所有区间的diff和，是0的进行长度比较
文中用的是hash匹配，同理就是当区间diff为0时，那么满足区间边界两点的值相等，因此当匹配到同样的值的时候，就和之前的长度比较一下，当然只需要记录第一次出现的边界即可！