前缀和算法：从暴力遍历到高效查询的蜕变（C++实现）

最新推荐文章于 2025-06-13 14:09:45 发布

六七_Shmily

最新推荐文章于 2025-06-13 14:09:45 发布

阅读量640

点赞数 15

分类专栏：数据结构与算法分析文章标签：算法 c++ 数据结构

本文链接：https://blog.youkuaiyun.com/2301_80215285/article/details/146484043

版权

数据结构与算法分析专栏收录该内容

39 篇文章

订阅专栏

前缀和算法：从暴力遍历到高效查询的蜕变

一、前缀和的本质与价值

前缀和（Prefix Sum）是算法领域的时空转换器，通过一次O(n)的预处理，将区间查询的时间复杂度从O(n)优化至O(1)。其核心思想是将原始数据的累积状态预存储，适用于频繁的区间查询场景。

二、前缀和的三重核心作用

1. 区间查询加速器

暴力解法：
每次查询遍历区间，时间复杂度O(n)

int sum = 0;
for(int i=l; i<=r; ++i) sum += arr[i];

前缀和优化：
预处理后查询时间复杂度O(1)

vector<int> prefix(n+1, 0);
for(int i=1; i<=n; ++i) 
    prefix[i] = prefix[i-1] + arr[i-1]; // 前缀和数组
int sum = prefix[r+1] - prefix[l]; // 区间和

2. 子数组问题转化器

将复杂的子数组问题转化为差值问题，例如：

寻找和为K的子数组数量（LeetCode 560）
寻找最长平衡子数组（LeetCode 525）

3. 高维数据处理器

通过升维拓展到矩阵区域和计算（LeetCode 304），将二维查询复杂度从O(mn)优化到O(1)。

三、前缀和的五大经典应用

应用1：一维区间和（LeetCode 303）

class NumArray {
    vector<int> prefix;
public:
    NumArray(vector<int>& nums) {
        prefix.resize(nums.size()+1);
        for(int i=1; i<=nums.size(); ++i)
            prefix[i] = prefix[i-1] + nums[i-1];
    }
    
    int sumRange(int left, int right) {
        return prefix[right+1] - prefix[left];
    }
};

应用2：二维矩阵和（LeetCode 304）

class NumMatrix {
    vector<vector<int>> prefix;
public:
    NumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        prefix = vector<vector<int>>(m+1, vector<int>(n+1, 0));
        for(int i=1; i<=m; ++i)
            for(int j=1; j<=n; ++j)
                prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] 
                              - prefix[i-1][j-1] + matrix[i-1][j-1];
    }
    
    int sumRegion(int r1, int c1, int r2, int c2) {
        return prefix[r2+1][c2+1] - prefix[r1][c2+1] 
             - prefix[r2+1][c1] + prefix[r1][c1];
    }
};

四、前缀和的四阶优化技巧

1. 空间压缩

对滚动计算场景使用变量替代数组：

int maxSubArray(vector<int>& nums) {
    int pre = 0, max_sum = INT_MIN;
    for(int x : nums){
        pre = max(pre + x, x); // 当前最大前缀和
        max_sum = max(max_sum, pre);
    }
    return max_sum;
}

2. 哈希表加速

解决子数组和为K的问题：

int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> count_map;
    count_map[0] = 1;
    int pre = 0, cnt = 0;
    for(int x : nums){
        pre += x;
        if(count_map.find(pre - k) != count_map.end())
            cnt += count_map[pre - k];
        count_map[pre]++;
    }
    return cnt;
}

3. 差分数组

处理区间更新问题（LeetCode 370）：

vector<int> getModifiedArray(int length, vector<vector<int>>& updates) {
    vector<int> diff(length + 1, 0);
    for(auto& u : updates){
        diff[u[0]] += u[2];
        diff[u[1]+1] -= u[2];
    }
    for(int i=1; i<length; ++i) 
        diff[i] += diff[i-1];
    diff.pop_back();
    return diff;
}

4. 多维扩展

三维空间区域和计算（科研计算场景）：

int cubeSum(int x1, int y1, int z1, int x2, int y2, int z2) {
    return prefix[x2][y2][z2] 
         - prefix[x1][y2][z2] - prefix[x2][y1][z2] - prefix[x2][y2][z1]
         + prefix[x1][y1][z2] + prefix[x1][y2][z1] + prefix[x2][y1][z1]
         - prefix[x1][y1][z1];
}