算法基础篇（6）差分_基础算法差分-优快云博客

前缀和与差分的核心思想是预处理，可以在暴力枚举的过程中，快速给出查询结果，从而优化时间复杂度，是经典的空间换时间的做法。前缀和与差分是一对互逆的运算。

1、一维差分

1.1 【模版】差分

算法思路：运用差分数组解决问题 -> 快速解决"将某一区间所有元素统一加上一个数"的操作。

首先预处理出来一个差分数组f[i]，表示当前元素与前一个元素的差值。再利用差分数组解决m次修改操作。性质：原数组[L，R]区间内全部加上k，相当于在差分数组f[L] += k，f[R] -= k。

类似的，我们也可以利用这个性质来创建差分数组。当我们读入a[i]时，相当于是在原位置加上a[i]，所以得到第二种创建差分数组的方式：f[i] += a[i]，f[i + 1] -= a[i]。

最后一个问题，如何还原出原数组呢？直接对差分数组做前缀和运算即可。

参考代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

const int N = 1e5 + 10;

int n, m;
//int a[N];
int f[N]; //差分数组

int main()
{
	cin >> n >> m;
	
	for (int i = 1;i <= n;i++)
	{
		//利用差分数组的定义创建差分数组
		//cin >> a[i];
		//f[i] = a[i] - a[i - 1];

		//利用差分数组的性质创建差分数组
		int x;
		cin >> x;
		f[i] += x;
		f[i + 1] -= x;
	}

	//处理 m 次修改操作
	while (m--)
	{
		int l, r, k;
		cin >> l >> r >> k;

		f[l] += k;
		f[r + 1] -= k;
	}

	//还原出原始的数组
	for (int i = 1;i <= n;i++)
	{
		//a[i] = f[i] + a[i - 1];
		//cout << a[i] << " ";

		f[i] = f[i - 1] + f[i];
		cout << f[i] << " ";
	}

	return 0;
}

注意：在差分数组使用的时候，必须在所有操作全部进行完毕之后，才能还原出原数组。

1.2 【练习】海底高铁

算法思路：找出每一段铁路的最小花费，然后累加。

那么，我们该如何求出每一段铁路要乘坐多少次呢？假如从城市1到城市4，就是把1~4这段区间内的次数统一加1，所以利用差分数组即可。

参考代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

const int N = 1e5 + 10;

int n, m;
int f[N]; //差分数组

int main()
{
	cin >> n >> m;

	// x->y
	int x;
	cin >> x;
	for (int i = 2;i <= m;i++)
	{
		int y;
		cin >> y;
		// x->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] + f[i];
	}

	//直接求结果
	int ret = 0;
	for (int i = 1;i < n;i++)
	{
		int a, b, c;
		cin >> a >> b >> c;

		ret += min(a * f[i], c + b * f[i]);
	}

	cout << ret << endl;

	return 0;
}

2、二维差分

2.1 【模版】二维差分

算法思路：利用差分矩阵解决问题->快速处理"将二维数组中，某一个子矩阵统一加上一个元素"的操作。

性质：在差分矩阵上求前缀和能够还原出修改之后的矩阵。在差分数组中，某一个格子执行+k操作，会影响以它为左上角，以[n，m]为右下角的这样一个子矩阵中，所有元素在求完前缀和之后，统一+k（如下图）。

所以，我们要进行额外的操作来抵消+k之后的一部分影响（如下图）。

参考代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

const int N = 1010;

int n, m;
int q;
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()
{
	cin >> n >> m >> q;
	//预处理差分矩阵
	for (int i = 1;i <= n;i++)
	{
		for (int j = 1;j <= m;j++)
		{
			int x;
			cin >> x;
			// [i,j]为左上角，[i,j]为右下角的矩阵，统一加上x
			insert(i, j, i, j, x);
		}
	}

	//处理q次操作
	while (q--)
	{
		int 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;
}

2.2 【练习】地毯

算法思路：直接利用差分数组来模拟这个过程。

参考代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
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()
{
	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;
}