差分+树上差分（详细说明+模板）

问题引入

差分的题目，常见的操作为：有一连续区间[1,n]，包含n个点，对任意的 1 <= u ,v<= n ，使得区间[u,v]中结点的值增加x，然后询问某点的权值。

树上差分的题目，常见的操作为：将一棵树上从u到v路径上的点或者边的权值加上x，询问某结点的权值

什么是差分

假设我们有一条链，链上的结点记为 1~n ，一共n个连续的结点，现在我们将这条链上任意区间中的结点增加一个值x，看到这里，大家想到的第一反应应该就是：这不是线段树吗？

确实，当我只有一条链的时候，用线段树可以实现 O(nlogn)的复杂度操作，但是如果有m条链，并且 0 < n ,m < 1e4，按照一般的思路，我们构建m棵线段树代表m条链，时间复杂度为 O(nmlogn)，嗯，运算大约1e9次，差不多1s了。

而差分可以解决这个问题，一条链的时候，用差分可以实现复杂度为 O(n + 常数)，不仅时间上比线段树更快，而空间和代码量都要小的多，当然，这并不是说差分可以替代线段树，在这里，我们考虑的是一种特殊情况，此时差分是比线段树更好的方法。

那么差分是如何实现O(n+常数)的复杂度的呢？我们将 val[] 定义为差分数组,值初始化为0，某次操作：令区间 [l,r] 的值增加x，此时我们用O(1)的时间执行: val[l] += x, val[r+1] -= x ， 一共k次操作，此时用时 O(2k) ，随后我们求差分数组val的前缀和sum，显然，只需要O(n)的时间即可，一共用时O(n+2k），然后m条链的时候就是O(mn + 常数)，大约1e8，比线段树快了一个 O(logn) 级别

什么是树上差分

简单差分是一条连续的链上进行的一段区间整体增加一个值，树上差分是将一棵树上从u到v路径上的点或者边的权值加上x。

众所周知，树中任意两点的路径是唯一的，而我们也知道任意两点u,v之间的路径，必然经过 lca(u,v)，路径描述为 u -> lca(u,v) ->v，此时我们也有一个差分数组 val[] ，值初始化为0，此时执行操作: val[u] += x , val[v] += x , val[lca[u,v)] -= x , val[ father[lca[u,v)]] -= x，执行完所有这样的操作之后，我们用 sum[] 记录每个结点的权值，sum[i] 的值为 i 和 i 的子树的val[] 之后，至于为什么，建议手动模拟一下

树上差分（增加路径中点的权值）

题目链接：https://www.luogu.org/problem/P3128

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>
#include<cmath>
#include<fstream>
#include<vector>
#include<stack>
#include <map>
#include <iomanip> 
#define bug cout << "**********" << endl
#define out cout<<"---------------"<<endl
#define show(x, y) "["<<x<<","<<y<<"] "
//#define LOCAL = 1;
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int mod = 1e8;
const int Max = 5e4 + 10;
const int Max2 = 5e3 + 10;

struct Edge
{
	int to, next;
}edge[Max<<1];

int n, k;
int head[Max], tot;

int lg[Max];				//log2 n 向下取整
int father[Max][25];		//倍增法求祖先
int deep[Max];				//记录深度
int val[Max];				//记录差分数组
int max_val;


void add(int u, int v)
{
	edge[tot].to = v;
	edge[tot].next = head[u];
	head[u] = tot++;
}

void dfs(int now, int fa, int depth)
{
	deep[now] = depth;
	father[now][0] = fa;

	for (int i = 1;i <= 20;i++)
		father[now][i] = father[father[now][i - 1]][i - 1];

	for (int i = head[now]; i != -1; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v != fa)
			dfs(v, now, depth + 1);
	}
}

int lca(int a, int b)
{
	if (deep[a] < deep[b]) swap(a, b);

	while (deep[a] != deep[b])
	{
		a = father[a][lg[deep[a] - deep[b]]];
	}

	/*for (int i = 20; i >= 0; i--)
		if (deep[father[a][i]] >= deep[b])
			a = father[a][i];*/

	if (a == b) return a;

	for (int i = 20; i >= 0;i--)
	{
		if (father[a][i] != father[b][i])
		{
			a = father[a][i];
			b = father[b][i];
		}
	}
	return father[a][0];
}


void insert(int s, int e)		//差分核心所在
{
	val[s]++;val[e]++;			//起止均加上权值
	int Lca = lca(s, e);
	val[Lca]--;val[father[Lca][0]]--;
}

void sum(int now)				//求差分数组的和
{
	for (int i = head[now]; i != -1; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v != father[now][0])
		{
			sum(v);
			val[now] += val[v];
		}
	}
	max_val = max(max_val, val[now]);
}

int main()
{
#ifdef LOCAL
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	lg[0] = -1;
	for (int i = 1;i < Max;i++)
		lg[i] = 1 + lg[i >> 1];
	while (scanf("%d%d", &n, &k) != EOF)
	{
		memset(head, -1, sizeof(head));tot = 0;
		memset(val, 0, sizeof(val));max_val = 0;

		for(int i = 1,u,v;i < n ;i ++)
		{
			scanf("%d%d", &u, &v);
			add(u, v);add(v, u);
		}
		dfs(1,0,1);			//根结点之上可能还有结点被标记


		for(int i = 1,u,v ;i <= k ;i ++)
		{
			scanf("%d%d", &u, &v);
			insert(u, v);
		}
		add(0, 1);
		sum(0);
		printf("%d\n", max_val);
	}

	return 0;
}

树上差分（增加路径中边的权值）

题目链接：暂时没有找到模板题....