平邑集训（讲课）

Day 1

CF148E

题目描述

解法

容易发现当第 $i$ 行要取出的数字个数固定时，所能得到的最大值与其他行无关。

设 $f_{i,j}$ 表示第 $i$ 行取 $j$ 个数字所能得到的最大和。

容易得出：

$f_{i,j} = \max{f_{i,j},sum_{i,l}+sum_{i,k_i}-sum_{i,k_i-(j-l)}}$

那么求 $f$ 数组的做法概括就为：枚举行（$i$）$\to$ 枚举取出的数字个数（$j$）$\to$ 枚举左边取出的数字（$l$）。时间复杂度 $O(n^3)$.

预处理完之后，考虑在每一组中有多少个数字，用分组背包来做。

CF95E

题目描述

解法

用并查集将每个联通快内的点数求出来，设为 $x_i$。

将题意转化为：有若干个整数（之和为 $n$），从中最少取出所有个数字，使得相加之和为幸运数。

将整数的数值看成体积，同时要求最少取多少个数字恰好装满体积为 $x$ 的背包。（$x$ 是任意一个幸运数）

用多重背包做，复杂度为 $O(nm log_{a_i})$，$n$ 是物品种类，$m$ 是枚举的背包大小。

Day 2

（补）

Day 3

（补）

Day 4

（补）

Day 5

树的直径

• 定义：树上有边权，距离最远的两个点之间的距离（最长链）。

所以直径有两种情况：根节点到叶子节点和叶子结点到叶子结点。

求法：

• 树形 DP

设 $1$ 号节点为根，$d_x$ 表示从节点 $x$ 出发，走向以 $x$ 为根的子树中能够到达的最远距离。

易得 $d_x=\max_{y_i \in son_x}(d_{y_i})+dis(x,y_i)$。

发现对于第二种情况不好求，继续设 $f_x$ 表示经过 $x$ 节点向书中最长链的长度。

易得 $f_x=\max_{y_i,y_j \in son_x}(d_{y_i}+d_{y_j}+dis(x,y_i)+dis(x,y_j))$。

其中 $dis(x,y_i),dis(x,y_j)$ 就是图中的黄边。

但是复杂度会爆，因为求 $f$ 数组的时间复杂度为 $O(n^2)$。

实际上可以在求 $d_y$ 的时候顺便求一下 $f_x$。

实现的时候可以用 $ans$ 记录答案，省下了数组 $f$。

点击查看代码

bool vis[200001];
int cnt,head[200001];
struct node
{
	int to,nxt,w;
}e[200001];
void add(int u,int v,int w)
{
	e[++cnt].to = v;
	e[cnt].w = w;
	e[cnt].nxt = head[u];
	head[u] = cnt;
}
int ans,d[200001];
void dfs(int u)
{
	vis[u] = 1;
	int i;
	for(i=head[u];i;i=e[i].nxt)
	{
		int v = e[i].to;
		if(vis[v])
			continue;
		dfs(v);
		ans = max(ans,d[u]+d[v]+e[i].w);
		d[u] = max(d[u],d[v]+e[i].w);
	}
	return;
}

• 贪心

也就是两遍 dfs。

1.从 $1$ 号出发，找到距离 $1$ 号节点最远的点 $p$。
2.从 $p$ 节点出发，找到距离 $p$ 节点最远的点 $q$。

所以从 $p$ 到 $q$ 的长度就是树的直径。

贪心是要证明的，所以证明一下 $p$ 一定是直径的一个端点。

证明：
反证法，设 $p$ 不是直径的一个端点，而 $p$ 是距离 $1$ 最远的点。
1.路径有交无重合。
假设有直径 $A-B$。
因为 $1-P>1-B,1-A$
所以 $P-B>A-B$
所以 $A-B$ 一定不会成为直径。
2.路径存有交有重合。
假设有直径 $A-B$。
因为 $M-P>A-M,M-B$
所以 $P-B>A-B$
所以 $A-B$ 一定不会成为直径。
3.完全无交。
假设有直径 $A-B$。
所以 $PM>MN+NB$，不然 $p$ 就不是距离 $1$ 最远的点了。
则 $PM+MN>NB$
则 $A-B=AN+NB$
所以 $PM+MN+NA=PA>AB$
所以 $A-B$ 一定不会成为直径。

注意：贪心方法不能有负边权。

点击查看代码

int cnt,head[200001];
struct node
{
	int to,nxt,w;
}e[200001];
void add(int u,int v,int w)
{
	e[++cnt].to = v;
	e[cnt].w = w;
	e[cnt].nxt = head[u];
	head[u] = cnt;
}
int d[200001];
int p;
void dfs(int u,int fa)
{
	int i;
	for(i=head[u];i;i=e[i].nxt)
	{
		int v = e[i].to;
		if(v==fa)
			continue;
		d[v] = d[u]+1;
		if(d[v]>d[p])
			p = v;
		dfs(v,u);
	}
	return;
}

P3629 · 巡逻

题目描述

连接。

解法

当 $k=1$ 时，一定是找个最长的链，连接端点，形成环。因此直接找直径即可。答案就是 $2\times(n-1)-直径+1$。

当 $k=2$ 时，第一条边就是连直径，第二条边需要分类讨论：

• 构成一个不与第一个环相交的环

如图：

只要再贪心一次(把第一条直径上的边忽略)就可以了。

• 构成一个与第一个环相交的环

如图：

---

对于这两种情况，可以一起求。具体做法：

1. 求出直径，那么就知道了 $2\times(n-1)-直径+1$ 的值。
2. 将直径上的边权从 $1$ 赋值为 $-1$，并再求出直径。

那就知道了 $2\times(n-1)-直径1-直径2+2$，化简也就是 $2\times n-直径1-直径2$。

代码

树网的核

原题。
加强版。

题目描述

给定一棵带边权无根树，在其直径上求出一段长度不超过 $s$ 的路径 $F$（核），使得离路径距离最远的点到路径的距离最短（题目中的定义是偏心距）。

解法

对于本题，中心点是唯一的，对于任意一条直径而言，求出的最小偏心距都是相等的。

• 解法一：枚举，时间复杂度 $O(n^3)$。

先求出直径的方案，枚举直径上距离不超过 $s$ 的两个点作为核的端点，标记核上的点，从核上的每个点出发 dfs，求出核以外的每个节点到核的最短距离。

取最大值就是当前的偏心距。

不断枚举核，并求出当前路径为核的偏心距，取个最小值即可。

然后就过了原题。

• 解法二：优化为 $O(n^2)$。

树网的核长度不超过 $s$，当核的一个端点确定为 $p$ 时，另一个端点 $q$ 应该越远越好且不超过 $s$。

维护一个 $cnt$ 数组即可。

• 解法三：二分答案，优化为 $O(nlogn)$。

剖析题目，要求最小的到核的最大距离，所以要最小化最大值，二分求解。

问题转化为，二分 $mid$，然后判定是否存在一个核，使得其偏心距不超过 $mid$？

从 $p$ 出发，找到一个不超过 $mid$ 的最远点 $x$；再从 $q$ 出发，找到一个不超过 $mid$ 的最远点 $y$。如图：

得到一个结论： $p$ 到 $x$ 之间的分叉的子树，其最远点到 $x$ 的距离不会超过到 $p$ 的距离。而 $q$ 到 $y$ 同理。

现在就剩下中间那一坨点了。

需要判断两件事：$x$ 到 $y$ 距离不超过 $s$ 与 $x,y$ 之间的子树上是否会超过 $mid$。

前者显然好判断，让 $x$ 距离 $y$ 最近即可；后者和解法二一样。

• 解法四：$O(n)$。

受解法三启发，我们表示一下偏心距离。如图：

此时偏心距离为 $\max(dis(p,u_i),dis(u_j,q),x)$

设 $d_{u_i}$ 表示从 $u_i$ 出发，不经过直径上的点能够达到最远的点的距离。显然可以预处理，时间复杂度 $O(n)$。

若以 $u_i$ 与 $u_j$ 为核的端点，此时偏心距为 $\max(dis_{u_i,u_j},dis_{u_j,u_i},\max_{i<k<j}(d_{u_k}))$。

发现后半部分的 $\max$ 不能做到 $O(1)$。

对于这个 $\max$，可以枚举 $i$，找到不超过 $s$ 的最远的 $u_j$。发现这是个在链上的滑动窗口，直接做就行。

代码

最近公共祖先

定义太简单，不说了。

• 向上标记法

1.让 $x$ 一直向上走到根节点，并标记走过的点（也就是他的祖先）；
2.让 $y$ 向上走，遇到的第一个被标记过的点就是 $x$ 和 $y$ 的 LCA。

所以单次找 LCA 的时间复杂度就是 $O(n)$ 的。

• 树上倍增法

设 $f_{x,k}$ 表示 $x$ 的 $2^k$ 辈祖先（$k\in [1,\log_2 n]$）。

例子：

通过手玩样例，发现 $f_{x,k}=f_{f_{x,k-1},k-1}$，而且如果祖先节点不存在，$f_{x,k}=0$

具体原理也就是 \(2^k=2^{k-1]+2^{k-1}\)，先走 $2^{k-1}$ 步再走 $2^{k-1}$ 步。

预处理 $f$ 数组时间复杂度是 $O(nlogn)$。

接下来就是正式求解了。

设 $d_x$ 表示 $x$ 的深度，且令 $d_x>=d_y$。

1.先把 $x$ 调整到与 $y$ 相同的深度，也就是 $x$ 向上走 $2^{logn},2^{logn-1},\cdots,2^1,2^0$ 步。跳完后，若深度已经小于 $y$，选择用更小的步长走；若此时 $x=y$（走到了同一层），则 $y$ 就是 LCA。
2.尝试将 $x,y$ 同同时向上走，步长依次为 $2^{logn},2^{logn-1},\cdots,2^1,2^0$ 步。若 $f_{x,k}\ne f_{y,k}$，则 $x=f_{x,k},y=f_{y,k}$。
3.$x,y$ 就差一步碰面，$ans=f_{x,0}$。

时间复杂度 $O(nlogn)$。

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 500000+114;
struct edge
{
	int to,w,nxt;
}e[N*2];
int cnt,head[N];
int n,m,s;
void add(int u,int v)
{
	++cnt;
	e[cnt].to = v;
//	e[cnt].w = w;
	e[cnt].nxt = head[u];
	head[u] = cnt;
}
int lg[N],f[N][30],d[N];
void dfs(int u,int fa)
{
	f[u][0] = fa;
	d[u] = d[fa]+1;
	int i;
	for(i=1;i<=lg[d[u]];i++)
		f[u][i] = f[f[u][i-1]][i-1];
	for(i=head[u];i;i=e[i].nxt)
		if(e[i].to!=fa)
			dfs(e[i].to,u);
	return;
}
int lca(int x,int y)
{
	if(d[x]<d[y])
		swap(x,y);
	while(d[x]>d[y])
		x = f[x][lg[d[x]-d[y]]-1];
	if(x==y)
		return x;
	int i;
	for(i=lg[d[x]]-1;i>=0;i--)
		if(f[x][i]!=f[y][i])
			x = f[x][i],y = f[y][i];
	return f[x][0];
}
int main()
{
	cin>>n>>m>>s;
	int i,j;
	for(i=1;i<n;i++)
	{
		int u,v;
		cin>>u>>v;
		add(u,v);
		add(v,u); 
	}
	for(i=1;i<=n;i++)
		lg[i] = lg[i-1]+(1<<lg[i-1]==i);
	dfs(s,0);
	while(m--)
	{
		int x,y;
		cin>>x>>y;
		cout<<lca(x,y)<<endl;
	}
	return 0;
}
 

• 离线做法

dfs 一颗树的过程中，将节点分成三类：

1.已经访问过并且回溯了的点，标记为 $2$。
2.已经访问，但没有回溯的点，标记为 $1$。
3.尚未访问的点，不标记。

发现了一些性质：对于正在访问的点 $x$，从根到 $x$ 的路径上标记都为 $1$，任意一个点 $y$，若标记为 $2$，则 $lca(x,y)$ 一定是 $y$ 向上走到根的路径中，第一个标记为 $1$ 的点。

当一个点刚刚获得了 $2$ 号标记，其父亲标记为 $1$，此时将其合并到父节点的集合。

当即将回溯到 $x$ 时，扫描与 $x$ 相关的所有询问（$y$ 标记为 $0$），可以回答所有标记为 $2$ 的 $y$ 的 $LCA(x,y)$。

P1967

题目描述

解法

加边方式类似最大生成树。

设 $f_{x,k}$ 表示 $x$ 的 $2^k$ 辈祖先，$len_{x,k}$ 表示 $x$ 的 $2^k$ 辈祖先之间最小的边。

所以 $len_{x,k}=min(len_{x,k-1},len_{f_{x,k-1},k-1})$。

（补）

树上差分

• 点差分

他能解决的问题：给定若干个 $(x,y)$，表示从 $x$ 点走到 $y$ 点。问每个点被经过的次数？

如果在序列上，直接差分再前缀和即可。树上也是如此。

例子：

将 $x$ 到根节点每个点 $+1$，将 $y$ 到根节点每个点 $+1$，再减去 $lca(x,y)$ 和 $fa_{lca(x,y)}$ 到根节点的距离即可。

也就是 cnt[x]++,cnt[y]++,cnt[lca(x,y)]--,cnt[fa[lca(x,y)]]--。

• 边差分

例子：

发现边权不好做，考虑下放在点权上。

转化为：

继续考虑差分，也就是 cnt[x]++,cnt[y]++,cnt[lca(x,y)] -= 2。

P3128

题目描述

解法

点差分板子。

代码

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 500000+114;
struct edge
{
	int to,w,nxt;
}e[N*2];
int cntt,head[N];
int n,m,s;
void add(int u,int v)
{
	++cntt;
	e[cntt].to = v;
//	e[cnt].w = w;
	e[cntt].nxt = head[u];
	head[u] = cntt;
}
int lg[N],f[N][30],d[N];
void dfs(int u,int fa)
{
	f[u][0] = fa;
	d[u] = d[fa]+1;
	int i;
	for(i=1;i<=lg[d[u]];i++)
		f[u][i] = f[f[u][i-1]][i-1];
	for(i=head[u];i;i=e[i].nxt)
		if(e[i].to!=fa)
			dfs(e[i].to,u);
	return;
}
int lca(int x,int y)
{
	if(d[x]<d[y])
		swap(x,y);
	while(d[x]>d[y])
		x = f[x][lg[d[x]-d[y]]-1];
	if(x==y)
		return x;
	int i;
	for(i=lg[d[x]]-1;i>=0;i--)
		if(f[x][i]!=f[y][i])
			x = f[x][i],y = f[y][i];
	return f[x][0];
}
int cnt[200001];
int ma = INT_MIN;
void get(int u,int fa)
{
	int i;
	for(i=head[u];i;i=e[i].nxt)
	{
		int v = e[i].to;
		if(v==fa)
			continue;
		get(v,u);
		cnt[u] += cnt[v];
	}
	ma = max(ma,cnt[u]);
}
int main()
{
	cin>>n>>m;
	s = 1;
	int i;
	for(i=1;i<n;i++)
	{
		int u,v;
		cin>>u>>v;
		add(u,v);
		add(v,u); 
	}
	for(i=1;i<=n;i++)
		lg[i] = lg[i-1]+(1<<lg[i-1]==i);
	dfs(1,0);
	while(m--)
	{
		int x,y;
		cin>>x>>y;
		int l = lca(x,y);
		cnt[x]++,cnt[y]++,cnt[l]--,cnt[f[l][0]]--;
	}
	get(1,0);
	cout<<ma<<endl;
	return 0;
}
 

P3258

AcWing 354

题目描述

解法

对于非树边 $(x,y)$ 而言，树上肯定有一个包含 $(x,y)$ 的环。

第一次切环上的树边，第二次一定切 $(x,y)$。

将 $(x,y)$ 所在环上的所有树边的权值都加 $1$。

如果是树边：

1. 边权值为 $0$，显然第二刀随便砍，$ans+m$。
2. 边权值为 $1$，只在一个环上，砍完以后只能砍非树边，所以 $ans+1$。
3. 边权值 $\ge 2$，则起码需要 $3$ 刀($\ge 2$ 刀非树边+当前边)，所以 $ans$ 不变。

代码

Day 6

DFS 序

• 时间戳

先了解什么时时间戳：在树的深度优先遍历中，以每个节点第一次被访问的顺序，以此给予这 $n$ 个节点 $1$ 到 $n$ 的整数标记，该标记被称为时间戳。

给个例子：

• 树的 DFS 序

在树的深度优先遍历中，对于每个节点进入递归后以及即将回溯各记录一次该点的编号，最后产生的长度为 $2$ 到 $n$ 的序列就被称为树的 DFS 序。

所以上面那棵树的 DFS 序就是

发现了一些性质：
1.每个节点在序列中恰好出现两次。
2.设 $l_x$ 和 $r_x$ 分别表示 $x$ 出现两次的位置，那么区间 $[l_x,r_x]$ 对应的就是在树上以 $x$ 为根的子树。

LOJ 144 · DFS 序 1

题目描述

1.树上 $u$ 节点的权值 $+x$。
2.询问 $u$ 子树的权值和。

解法

代码

LOJ 145 · DFS 序 2

题目描述

1.节点 $u$ 的子树上所有权值 $+x$。
2.询问 $u$ 子树的权值和。

解法

求出 DFS 序，相当于在 DFS 序上进行区间加和区间查询。

用树状数组或者带标记的线段树。

先来看看树状数组怎么区间加区间查询。在 $a$ 数组中，$[a_l,a_r]$ 加上 $d$。

设 $b$ 为差分数组，所以 $b_l+d$,$b_{r+1}-d$。

操作结束后，$a_x$ 增加的值也就是 $\sum_{i=1}^x b_i$。

$A$ 的前缀和 $[A_1,A_x]$ 也就是 $\sum_{i=1}^x a_i$。

$A$ 的前缀和增加量也就是 $\sum_{i=1}^x \sum_{j=1}^i b_j$。

发现这个东西不好维护，先手玩一下：$b_1$ 被加了 $x$，$b_2$ 被加了 $x-1$，$b_3$ 被加了 $x-2$，$b_i$ 被加了 $x-i+1$。

所以刚刚那个式子可以表示为 $\sum_{i=1}^x (x-i+1)\times b_i$。

$$\sum_{i=1}^x (x-i+1)\times b_i$$

$$=\sum_{i=1}^x [(x+1)\times b_i-i\times b_i]$$

$$=(x+1)\sum_{i=1}^x b_i-\sum_{i=1}^x i\times b_i$$

发现最后要维护的就是上面那个式子的两个 $\sum$。

开两个树状数组 $T_1,T_2$。

• 对于区间加 $l,r,d$：

1.在 $T_1$ 中 add(l,b)。
2.在 $T_1$ 中 add(r+1,-d)。

现在知道了前半部分的 $\sum$ 的值。

3.在 $T_2$ 中，add(l,l*d)。
4.在 $T_2$ 中，add(r+1,-(r+1)*d)。

现在知道了后半部分的 $\sum$ 的值。

• 对于区间求和 $q,l,r$：

[sum[r]+(r+1)*ask(T1,r)-ask(T2,r)]-[sum[l-1]+l*ask(T1,l-1)-ask(T2,l-1)]。

代码

LOJ 146 · DFS 序 3，树上差分 1

题目描述

1.路径权值加。
2.单点查询。
3.子树权值求和。

解法

对于操作 $1$ 可以直接树上差分，随着操作 $2$ 就变成了子树查询。

问题是如何解决操作 $3$。

设差分后， $v$ 节点的差分值是 $val_v$。若 $v$ 在以 $u$ 为根的子树中，考虑 $v$ 对于 $u$ 这个子树权值和的增加量贡献。

得出：

$$val_v\times(dep_v-dep_u+1)=val_v\times dep_v-(dep_u-1)\times val_v$$

于是 $u$ 的子树增加量之和就是：

$$(\sum_{v\in tree(u)} val_v\times dep_v)-(dep_u-1)\times \sum_{v\in tree(u)} val_v$$

代码

LOJ 147 · DFS 序 4

题目描述

1.单点加。
2.子树权值加。
3.查询路径权值和。

也就是和上一题的查询/修改反着来。

解法

我们已经知道 $u$ 到 $v$ 的权值和了，所以考虑维护每个点到根的路径权值和。

对于操作 $1$：节点 $u$ 增加 $x$，相当于以 $u$ 为根的子树中每个点到根的路径权值和都增加了 $x$。

对于操作 $2$：考虑 $u$ 子树中的点 $v$，$v$ 的变化。

$$(dep_v-dep_u+1)\times x=x\times dep_v-(dep_u-1)\times x$$

代码

Day 7

树上 DP

分两种情况：从根到叶子（$x$ 是由父亲决定），从叶子到根（$x$ 是由子树决定）。

区间 DP

步骤是：拆分区间和合并区间。

背包 DP

Day 8

（补）

Day 9

（补）

Day 10

（补）

Day 11

（补）

Day 12

（补）

Day 13

（补）

Day 14

（补）

Day 15

（补）

Day 16、17