二维前缀和

下面是一个二维数组，我们要求（1，1）到（2，2）区间内的所有元素的和，最原始的方法就是遍历每个元素然后一个一个加起来，此时时间复杂度为O(n*m)。

我们之前学过一维数组的前缀和那么我们可以这样优化一下，

此时时间复杂度优化到了O(min{n,m})。还可以在优化吗？
答案是可以的。
我们依然根据一维数组的前缀和的思想来考虑二维数组

在上面的公式中我们发现出现了i-1和j-1，那么我们就需要考虑边界防止i或j为0时造成数组越界，
1.当i=0且j=0 我们可以得到sum[0][0]=g[0][0]和sum{0,0}{0,0}=g[0][0]
2.当i=0 我们可以得到sum[0][i]=sum[0][i-1]+g[0][i](一维数组前缀和)
和sum{0,y1}{0,y2}=sum[0][y2]-sum[0][y1-1]
3.当j=0 我们可以得到sum[i][0]=sum[i-1][0]+g[i][0](一维数组前缀和)和sum{x1,0}{x2,0}=sum[x2][0]-sum[x1-1][0]

代码如下

#include<iostream> // 包含输入输出流的头文件
using namespace std; // 使用标准命名空间

const int n = 3, m = 4; // 定义二维数组的行数n和列数m
int g[n][m] = { {1,5,6,8},{9,6,7,3},{5,3,2,4}}; // 初始化二维数组g
int sum[n][m]; // 用于存储前缀和的二维数组

// 计算二维数组的前缀和
void pre_sum()
{
    sum[0][0] = g[0][0]; // 左上角元素的前缀和为其自身
    // 计算第一列的前缀和，只需逐行累加
    for (int i = 1; i < n; i++)
    {
        sum[i][0] = sum[i - 1][0] + g[i][0]; // 当前元素=上一行同一列元素的前缀和+当前元素
    }
    // 计算第一行的前缀和，只需逐列累加
    for (int j = 1; j < m; j++)
    {
        sum[0][j] = sum[0][j - 1] + g[0][j]; // 当前元素=前一列同一行元素的前缀和+当前元素
    }
    // 计算剩余部分的前缀和
    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j < m; j++)
        {
            // 二维前缀和公式：
            // 当前元素的前缀和 = 当前元素值 + 上一行同一列前缀和 + 当前行前一列前缀和 - 左上角重叠部分的前缀和
            sum[i][j] = g[i][j] + sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
        }
    }
}

// 获取子矩阵的元素和，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标
int get_sum(int x1, int y1, int x2, int y2)
{
    // 如果左上角坐标是(0,0)，直接返回sum[x2][y2]的值
    if (!x1 && !y1)
    {
        return sum[x2][y2];
    }
    // 如果x1是0，说明子矩阵的上边界在第一行
    // 结果为整个矩形的前缀和减去子矩阵左侧部分的前缀和
    if (!x1)
    {
        return sum[x2][y2] - sum[x2][y1 - 1];
    }
    // 如果y1是0，说明子矩阵的左边界在第一列
    // 结果为整个矩形的前缀和减去子矩阵上方部分的前缀和
    if (!y1)
    {
        return sum[x2][y2] - sum[x1 - 1][y2];
    }
    // 其他情况，返回整个矩形的前缀和，减去子矩阵左侧和上方的前缀和，并加上左上角重叠部分的前缀和
    return sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
}

int main()
{
    pre_sum(); // 先计算前缀和
    // 输出从(1, 1)到(2, 2)的子矩阵和，以及从(0, 1)到(1, 3)的子矩阵和
    cout << get_sum(1, 1, 2, 2) << " " << get_sum(0, 1, 1, 3);

    return 0; // 程序结束
}

二维差分

有一个二维数组我们对某个区间内的所有元素进行加减操作，如下图所示

我们在一维数组中操作的时候我们是打标记，在d数组中某个下标的元素+1，他会影响到后面的所有元素，那么假如说我们在二维数组中的二维数组d中某个元素+1会影响那些元素呢？

我们可以发现在二维数组中我们需要打四个标记通过这个图我们可以写出这样的公式，我们对一个初始化为0的数组d进行操作，根据差分标记来改变数组d,然后对数组d进行前缀和，得到前缀和数组sumd,最后将前缀和数组加到原来的数组即可。

代码如下

#include<iostream> // 包含输入输出流的头文件
using namespace std; // 使用标准命名空间

const int n = 3, m = 4; // 定义二维数组的行数n和列数m
int g[n][m] = { {1,5,6,8},{9,6,7,3},{5,3,2,4} }; // 初始化二维数组g，用于存储原始矩阵
int sum[n][m]; // 用于存储前缀和的二维数组
int d[n + 1][m + 1] = { 0 }; // 定义二维差分数组d，多一行一列以处理边界问题

// 计算前缀和并更新g数组
void pre_sum()
{
    sum[0][0] = d[0][0]; // 左上角的前缀和为差分数组d的值
    // 计算第一列的前缀和，只需逐行累加
    for (int i = 1; i < n; i++)
    {
        sum[i][0] = sum[i - 1][0] + d[i][0];
    }
    // 计算第一行的前缀和，只需逐列累加
    for (int j = 1; j < m; j++)
    {
        sum[0][j] = sum[0][j - 1] + d[0][j];
    }
    // 计算其余部分的前缀和
    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j < m; j++)
        {
            // 二维前缀和公式
            sum[i][j] = d[i][j] + sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
        }
    }
    // 将差分作用应用到原始矩阵g上
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            g[i][j] += sum[i][j]; // 更新g[i][j]为修改后的值
        }
    }
}

// 输出矩阵g
void print()
{
    for (int i = 0; i < n; i++) // 遍历每一行
    {
        for (int j = 0; j < m; j++) // 遍历每一列
        {
            cout << g[i][j] << " "; // 输出g矩阵中的元素
        }
        cout << endl; // 换行
    }
}

// 获取子矩阵的元素和，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标
int get_sum(int x1, int y1, int x2, int y2)
{
    if (!x1 && !y1)
    {
        return sum[x2][y2]; // 如果子矩阵的左上角是(0,0)，直接返回sum[x2][y2]
    }
    if (!x1)
    {
        return sum[x2][y2] - sum[x2][y1 - 1]; // 如果子矩阵在第一行，减去左侧部分的前缀和
    }
    if (!y1)
    {
        return sum[x2][y2] - sum[x1 - 1][y2]; // 如果子矩阵在第一列，减去上方部分的前缀和
    }
    // 其他情况，使用前缀和公式计算子矩阵的和
    return sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
}

// 在差分数组d上应用区间更新
void add(int x1, int y1, int x2, int y2, int val)
{
    // 根据二维差分数组的性质，更新四个点
    d[x1][y1] += val;          // 左上角增加val
    d[x2 + 1][y1] -= val;      // 下方减去val
    d[x1][y2 + 1] -= val;      // 右侧减去val
    d[x2 + 1][y2 + 1] += val;  // 右下角加上val
}

// 输出差分数组d
void printD()
{
    for (int i = 0; i < n + 1; i++) // 遍历差分数组的行
    {
        for (int j = 0; j < m + 1; j++) // 遍历差分数组的列
        {
            cout << d[i][j] << " "; // 输出d矩阵中的元素
        }
        cout << endl; // 换行
    }
}

int main()
{
    // 调用add函数，进行两次区间更新
    add(0, 0, 2, 1, 3);  // 在区域(0,0)到(2,1)增加3
    add(1, 1, 2, 2, -1); // 在区域(1,1)到(2,2)减少1
    
    // printD(); // 如果想调试差分数组d的状态，可以取消注释这一行
    
    pre_sum(); // 计算前缀和并更新矩阵g
    print();   // 输出更新后的矩阵g
    
    return 0; // 程序结束
}

二位前缀和与二维差分源码