NO.60十六届蓝桥杯备战|基础算法-差分|一维差分|海底高铁|二维差分|地毯(C++)

前缀和与差分的核⼼思想是预处理，可以在暴⼒枚举的过程中，快速给出查询的结果，从⽽优化时间复杂度。
是经典的⽤空间替换时间的做法。

差分

解法1：暴力模拟，时间复杂度n乘m
解法2：利用差分数组解决问题，快速解决将某一个区间所有元素统一加上一个数的操作差分模板题，先「创建」差分数组，然后根据差分数组的「性质」处理q次区间修改，最后「还原」出来原始的数组。

1. 创建差分数组，根据定义：f[i] = a[i] - a[i - 1]
   也可以根据差分数组的性质：f[i] += a[i], f[i + 1] -= a[i]
   

差分数组fi表示：原数组第i项与第i-1项的差值
2. 根据差分数组的性质处理q区间修改：f[L] += c, f[R + 1] -= c

3. 还原经过q 次询问之后的a 数组：对差分数组做⼀次「前缀和」，就可以还原出原数组
   差分数组，根据定义：f[i] = a[i] - a[i - 1]
   原数组：

a[1] = f[1]
a[2] = a[2] - a[1] + a[1] = f[2] + f[1]
a[3] = a[3] - a[2] + a[2] - a[1] + a[1] = f[3] + f[2] + f[1] 

a[i] = f[i] - f[i-1] + f[i-2] + ... + f[1]

#include 
using namespace std;

typedef long long LL;

const int N = 1e5 + 10;
int n, m;
LL a[N];
LL f[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    cin >> n >> m;
    //创建差分数组
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        f[i] = a[i] - a[i-1];
    }
    //处理m
    while (m--)
    {
        LL l, r, k; cin >> l >> r >> k;
        f[l] += k; f[r+1] -= k;
    }
    //还原原始数组
    for (int i = 1; i <= n; i++)
    {
        a[i] = a[i-1] + f[i];
        cout << a[i] << " ";
    }
    
    return 0;
}

#include 
using namespace std;

typedef long long LL;

const int N = 1e5 + 10;
int n, m;
LL f[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    cin >> n >> m;
    //创建差分数组
    for (int i = 1; i <= n; i++)
    {
        LL x; cin >> x;
        f[i] += x;
        f[i+1] -= x;
    }
    //处理m
    while (m--)
    {
        LL l, r, k; cin >> l >> r >> k;
        f[l] += k; f[r+1] -= k;
    }
    //还原原始数组
    for (int i = 1; i <= n; i++)
    {
		f[i] = f[i-1] + f[i];
		cout << f[i] << " ";
    }
    
    return 0;
}

P3406 海底高铁 - 洛谷

先考虑如何让花费最⼩，想要求最⼩花费，需要知道每⼀段⾼铁被「乘坐了多少次」，记作f[i]，那么最⼩花费就是「买票的花费」与「买卡的花费」两者之间的最⼩值：

• 买票花费：a[i] × f[i];
• 买卡花费，乘⻋花费+⼯本费：b[i] × f[i] + c[i];
• 那么最⼩花费就是：mincost = min(a[i] × f[i], b[i] × f[i] + c[i])
  接下来考虑如何求出每⼀段⾼铁被「乘坐了多少次」。根据访问城市的序列$p_1,p_2,p_3,\dots ,p_m$可知，对于任意⼀次访问$p_i\sim p_{i+1}$，我们会乘坐$[p_i\sim p_{i+1}-1]$之间所有的⾼铁，⽐如$p_i=3,p_{i+1}=6$，那么$[3,5]$之间所有的⾼铁都会被乘坐⼀次，相当于每个数都加上1 ，「注意6位置不会乘坐到」。那么我们就可以利⽤「差分数组」：
• 创建⼀个全为0 的差分数组f；
• 遍历访问序列，对于每⼀次访问：f[pi]++, f[pi+1]--;
• 然后对差分数组做⼀次前缀和，就得到每个⾼铁乘坐的次数
  注意城市访问的序列有可能pi > pi+1 ，此时应该「交换」⼀下顺序。

#include 
using namespace std;

typedef long long LL;
const int N = 1e5 + 10;
int n, m;
LL f[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    int x; cin >> x;
    for (int i = 2; i <= m; i++)
    {
        int y; cin >> y;
        if (x > y) f[y]++, f[x]--;
        else f[x]++, f[y]--;
        x = y;
    }
    //还原原数组
    for (int i = 1; i <= n; i++) f[i] += f[i - 1];
    //结果
    LL ret = 0;
    for (int i = 1; i < n; i++)
    {
        LL a, b, c; cin >> a >> b >> c;
        ret += min(a * f[i], c + b * f[i]);
    }
    cout << ret << endl;
    
    return 0;
}

二维差分

解法1：暴力模拟
解法2：利用差分矩阵
⼆维差分模板题，先根据差分矩阵的「性质」创建差分矩阵，然后根据差分矩阵的「性质」处理q次区间修改，最后利⽤「前缀和」还原出来原始的矩阵。因此，重点就是差分矩阵的「性质」。
可以类⽐「⼀维差分数组」的性质，推导出「⼆维差分矩阵」的性质：

• 在差分数组中某个位置标记：表⽰后续元素统⼀被修改；
• 在差分数组中求前缀和：能够还原出原始数组。
  假设我们需要将原始矩阵a中，以$(x_1,y_1)$为左上⻆，$(x_2,y_2)$为右下⻆的⼦矩阵的每个元素都加上k：
  

在差分矩阵中：

• 将$(x_1,y_1)$位置加上一个k，求前缀和之后，会把紫绿黄粉区域的所有元素都加上k；为了抵消k
• 将$(x_1,y_2+1)$与$(x_2+1,y_1)$位置都减去一个k，这样黄绿区域恢复正常，但是粉色区域在上述操作中会被统一减去一个k，需要抵消掉
• 将$(x_2+1,y_2+1)$位置加上k
  这样就可以在差分矩阵求前缀和之后，还原出原始矩阵

第一步：预处理差分数组
读一个位置，直接带入差分矩阵性质
第二步：利用差分数组解决m次修改
第三步：还原原始矩阵
对差分数组求前缀和

#include 
using namespace std;

typedef long long LL;

const int N = 1010;

int n, m, q;
LL f[N][N];

//差分矩阵性质
void insert(int x1, int y1, int x2, int y2, int k)
{
    f[x1][y1] += k;
    f[x1][y2+1] -= k;
    f[x2+1][y1] -= k;
    f[x2+1][y2+1] += k;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    cin >> n >> m >> q;
    //预处理
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            LL x; cin >> x;
            //[i][j]为左上角，[i][j]为右下角的矩阵，加上x，
            insert(i, j, i, j, x);
        }
    }
    //处理q次修改
    while (q--)
    {
        LL x1, y1, x2, y2, k; cin >> x1 >> y1 >> x2 >> y2 >> k;
        insert(x1, y1, x2, y2, k);
    }
    //还原数组
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            f[i][j] = f[i-1][j] + f[i][j-1] -f[i-1][j-1] + f[i][j];
            cout << f[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

P3397 地毯 - 洛谷

#include 
using namespace std;

const int N = 1010;
int n, m;
int f[N][N];

void insert(int x1, int y1, int x2, int y2, int k)
{
    f[x1][y1] += k;
    f[x1][y2+1] -= k;
    f[x2+1][y1] -= k;
    f[x2+1][y2+1] += k;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    while (m--)
    {
        int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
        insert(x1, y1, x2, y2, 1);
    }
    //还原修改之后的数组
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            f[i][j] = f[i-1][j] + f[i][j-1] - f[i-1][j-1] + f[i][j];
            cout << f[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}