垃圾ACMer的暑假训练220706

220706

Codeforces Round #803 (Div. 2) A. XOR Mixup

原题指路:https://codeforces.com/contest/1698/problem/A

题意

现有含$(n-1)$个元素的整数序列$a$,令$x$为序列元素的异或值,将$x$添加到$a$的末尾使其称为长度为$n$的序列,随机调换$a$中元素的位置(可能保持不变).

有$t(1\le t\le 1000)$组测试数据.每组测试数据输入一个长度为$n(2\le n\le 100)$的序列$a_1,\cdots ,a_n(0\le a_i\le 127)$,表示由原始序列$a$经上述操作后得到的序列.输出任一个满足条件的$x$,可以证明这样的$x$存在.

思路

因构建出新序列后随机调换$a$中元素的位置,则新序列中各个位置等价,即都有可能是$x$的位置.不失一般性,不妨设新序列的前$(n-1)$个元素为初始序列的元素,最后一个元素为$x$.

以$n=4$为例,设初始序列 a : { a 1 , a 2 , a 3 } a:\{a_1,a_2,a_3\} a:{a1​,a2​,a3​},则$x=a_1\mathrm{x}\mathrm{o}\mathrm{r}{a}_2\mathrm{x}\mathrm{o}\mathrm{r}{a}_3$,构成的新序列 a : { a 1 , a 2 , a 3 , x } a:\{a_1,a_2,a_3,x\} a:{a1​,a2​,a3​,x}.考察序列的后$(n-1)$个元素,注意到$a_2\mathrm{x}\mathrm{o}\mathrm{r}{a}_3\mathrm{x}\mathrm{o}\mathrm{r}x=a_1$,即序列的后$(n-1)$个元素的异或值等于$a_1$,显然可通过调整$a_1,a_2,a_3$的位置使得后$(n-1)$个元素的异或值等于第一个元素,而这正是$x$的定义.因新序列中各个位置等价,故新序列中每个元素都可能是$x$,任意输出一个即可.

代码

int main() {
	CaseT{
		int n; cin >> n;
		int x;
		for (int i = 0; i < n; i++) cin >> x;	
		cout << x << endl;
	}
}

---

---

Codeforces Round #803 (Div. 2) B. Rising Sand

原题指路:https://codeforces.com/contest/1698/problem/B

题意

对含有$n$个数的整数序列$a_1,\cdots ,a_n$.称一个数$a_i(1<i<n)$是高的,如果$a_i>a_{i-1}+a_{i+1}$.注意首元素和尾元素不是高的.

有$t(1\le t\le 1000)$组测试数据,每组测试数据输入一个$n,k(3\le n\le 2\mathrm{e}5,1\le k\le n)$,表示整数序列的长度.现可在序列中取一个长度为$k$的连续区间,并将其中的元素$+1$.求经过若干次(可能是$0$次)操作后序列中高的元素的个数的最大值.数据保证所有测试样例的$n$之和不超过$2\mathrm{e}5$.

思路

类似于$n$个人站成一排,时间只对其中某个区间内的人流逝,问若干年后最多几个人的年龄是高的.注意到年龄差不变.

(1)$k=1$时:

​ ①若$n$是奇数,则可通过若干次操作使得序列中偶数位的数都是高的,$ans=\lfloor \frac{n-1}{2}\rfloor$.

​ ②若$n$为偶数,则可通过若干次操作使得序列中除尾元素的偶数位的数都是高的,$ans=\lfloor \frac{n-1}{2}\rfloor$.

(2)$k\ne 1$时:

​ 考察序列$a_1,\cdots ,a_{i-1},a_i,a_{i+1},\cdots ,a_n$,

​ 若选择区间$[a_{i-1},a_i]$进行操作,则$a_i$的邻域变为$a_{i-1}+1,a_i+1,a_{i+1}$.若$a_i+1$是高的,则$a_i+1>a_{i-1}+1+a_{i+1}$,即$a_i>a_{i-1}+a_{i+1}$,亦即操作对$a_i$是否是高的无贡献.同理选择区间$[a_i,a_{i+1}]$、$[a_{i-1},a_i,a_{i+1}]$操作也无贡献.故$a_i$是否是高的取决于其在原序列中是否是高的,对原序列统计一遍高的元素的个数即可.

代码

int main() {
	CaseT{
		int n, k; cin >> n >> k;
		vi a(n);
		for (int i = 0; i < n; i++) cin >> a[i];
		if (k == 1) {
			cout << (n - 1) / 2 << endl;
			continue;
		}
		else {
			int ans = 0;
			for (int i = 1; i < n - 1; i++) ans += (a[i] > a[i - 1] + a[i + 1]);
			cout << ans << endl;
		}
	}
}

---

---

Codeforces Round #803 (Div. 2)

原题指路:https://codeforces.com/contest/1698/problem/C

题意

称一个序列$a_1,\cdots ,a_n$是好的,如果对$\forall 1\le i<j<k\le n,\exists 1\le l\le ns.t.a_i+a_j+a_k=a_l$。

有$t(1\le t\le 1000)$组测试数据.每组测试数据输入一个长度为$n(3\le n\le 2\mathrm{e}5)$的整数序列$a_1,\cdots ,a_n(-1\mathrm{e}9\le a_i\le 1\mathrm{e}9)$.若该序列是好的,输出"YES",否则输出"NO".数据保证所有测试数据的$n$之和不超过$2\mathrm{e}5$.

思路

(1)若序列中至少有$3$个正数,设其中前三大为$x,y,z$,则数$x+y+z\notin a$.故序列中至多有$2$个正数.同理至多有$2$个负数.

(2)①若序列中有$1$个$0$,则是否$\exists a_l\in as.t.a_i+a_j+0=a_l$取决于$a_i+a_j$是否等于$a_l$.

​ ②若序列中有$2$个$0$,注意到$a_i+0+0=a_i$恒成立.

​ ③若序列中至少有$3$个$0$,注意到除保证$a_i+0+0=a_i$外,还保证$0+0+0=0$,显然这是多余的.故序列中至多有$2$个$0$.

综上,序列中至多有$6$个数,暴力检查是否满足好的条件即可.

代码

void solve() {
	int n; cin >> n;
	vi positive, negative;  // 正数、负数
	vi arr;  // 最终序列
	while (n--) {
		int x; cin >> x;
		if (x > 0) positive.push_back(x);
		else if (x < 0) negative.push_back(x);
		else if (arr.size() < 2) arr.push_back(x);  // x=0
	}

	if (positive.size() > 2 || negative.size() > 2) {
		cout << "NO" << endl;
		return;
	}

	for (auto item : positive) arr.push_back(item);
	for (auto item : negative) arr.push_back(item);

	for (int i = 0; i < arr.size(); i++) {
		for (int j = i + 1; j < arr.size(); j++) {
			for (int k = j + 1; k < arr.size(); k++) {
				bool ok = false;
				for (int l = 0; l < arr.size(); l++) 
					if (arr[i] + arr[j] == arr[l] - arr[k]) ok = true;  // 防爆int
				if (!ok) {
					cout << "NO" << endl;
					return;
				}
			}
		}
	}
	cout << "YES" << endl;
}

int main() {
	CaseT{
		solve();
	}
}

---

---

ACWing PAT甲级

13. 链表

13.1 共享 ($0.2\mathrm{s}$)

题意

存储单词时,可用链表逐字符存储.若两单词有相同后缀,可共享一个子链表.

如"loading"和"beging"的存储如下:

输入第一行包含两个节点地址和一个整数$n(2\le n\le 1\mathrm{e}5)$,两地址分别是两单词首字母节点的地址(地址是一个$5$位的正整数,$NULL$的地址为$-1$),$n$是总节点数.

接下来$n$行每行包含一个节点信息,格式为$AddressDataNext$,即当前节点地址、节点存储的字母($A\sim Z,a\sim z$)、下一节点的地址.

若两单词存在相同后缀,输出相同后缀的起始节点的地址;否则输出$-1$.

思路

先建出两个链表,遍历一遍第一个链表,把地址存在哈希表中.再遍历第二个链表,若当前节点的地址在哈希表中,则该节点地址为相同后缀的起始节点的地址.若遍历完第二个链表,则两单词无相同后缀.

因地址是$5$位数,可不用哈希表,直接用一个bool数组.

代码

const int MAXN = 1e5 + 5;
int n;  // 总节点数
int head1, head2, nxt[MAXN];
char val[MAXN];  // 节点的数据域
bool vis[MAXN];

int main() {
	cin >> head1 >> head2 >> n;
	for (int i = 0; i < n; i++) {
		int add, ne; char ch; cin >> add >> ch >> ne;
		val[add] = ch, nxt[add] = ne;
	}

	for (int i = head1; ~i; i = nxt[i]) vis[i] = true;  // 遍历第一个链表

	for (int i = head2; ~i; i = nxt[i]) 
		if (vis[i]) return printf("%05d", i), 0;  // 找到第一个公共节点
	
	cout << -1;
}

---

---

13.2 反转链表 ($0.4\mathrm{s}$)

题意

给定一个常数$k$和单链表$l$,对$l$上每$k$个元素做一次反转,若$l$的最后不足$k$个元素,则不反转.

输入第一行包含头节点的地址、总结点数$n(1\le n\le 1\mathrm{e}5)$和常数$k(1\le k\le n)$.节点地址用一个$5$位非负整数表示(可能含前导零),$NULL$用$-1$表示.

接下来$n$行每行描述一个节点信息,格式为$AddressDataNext$,即当前节点地址、节点存储的整数、下一节点的地址.

输出操作后的链表,从头节点开始依次输出,格式与输入相同.

思路

在链表上不易做反转.先将链表的节点地址依次存到一个vector里,在vector上做反转后,再将vector转为链表.

设操作后vector元素为$a_1,\cdots ,a_n$.每个节点的地址、数据域不变,令$nxt[a_1]=a_2,nxt[a_2]=a_3,\cdots ,nxt[a_{n-1}]=a_n,nxt[a_n]=-1$即可.

代码

const int MAXN = 1e5 + 5;
int n, k;  // 总节点数、常数
int head, val[MAXN], nxt[MAXN];

int main() {
	cin >> head >> n >> k;
	for (int i = 0; i < n; i++) {
		int add, data, ne; cin >> add >> data >> ne;
		val[add] = data, nxt[add] = ne;
	}

	vi arr;
	for (int i = head; ~i; i = nxt[i]) arr.push_back(i);

	for (int i = 0; i + k - 1 < arr.size(); i += k)   // 有k个元素才反转
		reverse(arr.begin() + i, arr.begin() + i + k);
	
	for (int i = 0; i < arr.size(); i++) {
		printf("%05d %d ", arr[i], val[arr[i]]);
		if (i + 1 == arr.size()) cout << -1 << endl;
		else printf("%05d\n", arr[i + 1]);
	}
}

---

---

13.3 删除链表重复数据 ($0.4\mathrm{s}$)

题意

给定一个单链表$l$,其每个节点上存有一个键值.现需删除有重复键值的绝对值的节点,即对每个键值$k$,只保留键值或其绝对值为$k$的第一个节点,同时将被删掉的节点存在另一个单链表中.

输入第一行包含头节点的地址和节点总数$n(1\le n\le 1\mathrm{e}5)$,节点地址是一个$5$位非负整数(可能含前导零),$NULL$用$-1$表示.

接下来$n$行每行描述描述一个节点信息,格式为$AddressKeyNext$,即当前节点地址、节点的键值(绝对值不超过$1\mathrm{e}4$)、下一节点的地址.

按顺序输出结果链表和被删除的节点的链表,格式与输入相同.

思路

建出链表,遍历一遍,若该键值的绝对值未出现过,将其节点地址插入到第一个vector中,否则插入到第二个vector中,再将vector转为链表.

代码

const int MAXN = 1e5 + 5;
int n;  // 总节点数、常数
int head, val[MAXN], nxt[MAXN];
bool vis[MAXN];

int main() {
	cin >> head >> n;
	for (int i = 0; i < n; i++) {
		int add, key, ne; cin >> add >> key >> ne;
		val[add] = key, nxt[add] = ne;
	}

	vi arr1, arr2;
	for (int i = head; ~i; i = nxt[i]) {
		int cur = abs(val[i]);
		if (vis[cur]) arr2.push_back(i);
		else {
			vis[cur] = true;
			arr1.push_back(i);
		}
	}
	
	for (int i = 0; i < arr1.size(); i++) {
		printf("%05d %d ", arr1[i], val[arr1[i]]);
		if (i + 1 == arr1.size()) cout << -1 << endl;
		else printf("%05d\n", arr1[i + 1]);
	}
	for (int i = 0; i < arr2.size(); i++) {
		printf("%05d %d ", arr2[i], val[arr2[i]]);
		if (i + 1 == arr2.size()) cout << -1 << endl;
		else printf("%05d\n", arr2[i + 1]);
	}
}

---

---

13.4 链表元素分类 ($0.4\mathrm{s}$)

题意

给定一个单链表,对其元素进行分类排列,使得所有负值元素都排在非负值元素的前面,且区间$[0,k]$内的元素都排在大于$k$的元素前面,要求不改变每一类内部元素的顺序.

输入第一行包含头节点的地址、总结点数$n(1\le n\le 1\mathrm{e}5)$和常数$k(1\le k\le n)$.节点地址用一个$5$位非负整数表示(可能含前导零),$NULL$用$-1$表示.

接下来$n$行每行描述一个节点信息,格式为$AddressDataNext$,即当前节点地址、节点存储的整数(数的绝对值不超过$1\mathrm{e}5$)、下一节点的地址.

输出操作后的链表,从头节点开始依次输出,格式与输入相同.

思路

最后排序结果分为三段:$<0$的元素、$[0,k]$的元素、$>k$的元素.

开3个vector存三类元素,再合并.

代码

const int MAXN = 1e5 + 5;
int n, k;  // 总节点数、常数
int head, val[MAXN], nxt[MAXN];

int main() {
	cin >> head >> n >> k;
	for (int i = 0; i < n; i++) {
		int add, key, ne; cin >> add >> key >> ne;
		val[add] = key, nxt[add] = ne;
	}

	vi arr1, arr2, arr3;
	for (int i = head; ~i; i = nxt[i]) {
		int cur = val[i];
		if (cur < 0) arr1.push_back(i);
		else if (cur <= k) arr2.push_back(i);
		else arr3.push_back(i);
	}
	
	arr1.insert(arr1.end(), arr2.begin(), arr2.end());
	arr1.insert(arr1.end(), arr3.begin(), arr3.end());

	for (int i = 0; i < arr1.size(); i++) {
		printf("%05d %d ", arr1[i], val[arr1[i]]);
		if (i + 1 == arr1.size()) cout << -1 << endl;
		else printf("%05d\n", arr1[i + 1]);
	}
}

---

---

10. 并查集

10.1 战争中的城市 ($0.4\mathrm{s}$)

题意

假设战争中,若一个城市被敌人占领,则从该城市出发和通往该城市的公路都将关闭.现需判断是否需要维修其他公路来保证其余城市连通.

输入第一行包含三个整数$n,m,k\left(2\le n\le 1000,1\le m\le \frac{n(n-1)}{2},1\le k\le n,km\le 3.5\mathrm{e}6\right)$,分别表示城市总数、公路总数和重点关注城市的数量,城市编号$1\sim n$.

接下来$m$行每行输入两个整数$a,b(1\le a,b\le n)$,表示城市$a$和$b$间存在公路.数据保证初始时所有城市连通.

最后一行包含$k$个整数,表示重点关注城市的编号.

输出$k$行,每行输出当该重点城市被占领时,为保证其余城市的连通性至少需维修多少条公路.

思路

不要将问题看成带删除一个节点的并查集,而是对每个询问,以删去节点后剩下的节点和边建立并查集.

用并查集维护连通块,若最后有$cnt$个连通块,则$ans=cnt-1$.

时间复杂度$O(k(n+m))$.

代码

const int MAXN = 1005, MAXM = 5e5 + 5;
int n, m, k;  // 城市数、公路数、查询数
struct Edge { int u, v; }edges[MAXM];
int fa[MAXN];

int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

int main() {
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) cin >> edges[i].u >> edges[i].v;

	while (k--) {
		int x; cin >> x;
		
		for (int i = 1; i <= n; i++) fa[i] = i;
		int cnt = n - 1;  // 当前连通块数
		for (int i = 0; i < m; i++) {  // 枚举所有边
			int u = edges[i].u, v = edges[i].v;
			if (u != x && v != x) {  // 不是重点关注城市
				u = find(u), v = find(v);
				if (u != v) {
					fa[u] = v;
					cnt--;  // 更新当前连通块数
				}
			}
		}
		cout << cnt - 1 << endl;
	}
}

---

---

10.2 家产 ($0.2\mathrm{s}$)

题意

给定每个人的家庭成员和ta自己名下的不动产信息,求每个家庭的成员数、人均不动产面基、人均房产套数.

第一行输入整数$n(1\le n\le 1000)$.接下来$n$行,每行输入一个拥有房产的人员的信息,格式为$IDFatherMotherkChil{d}_1\cdots Chil{d}_{k}M\_estateArea$,其中$ID$是每个人独一无二的$4$位标识号,$Father$和$Mother$是其父母的$ID$号(父母去世用$-1$表示),$k$是孩子数,$Chil{d}_i$是第$i(1\le i\le k\le 5)$的$ID$,$M\_estate$是其名下房产的数量,$Area$是其名下房产的面积.数据保证每个人名下的房产不超过$100$套,每个人名下的房产总面积不超过$5\mathrm{e}4$.

按人均房产面积降序输出所有家庭信息,若人均房产面积相等,按$ID$升序排序.输出格式为$IDMAVG\_setsACG\_area$,其中$ID$为家庭成员中编号最小的成员的编号,$M$为家庭成员数,$AVG\_sets$为人均房地产数,$AVG\_area$为人均房地产面积.

思路

最后按$ID$升序排序输出,可在集合的根节点多开一个变量来记录集合的最小$ID$,或在合并集合时将根节点编号较大的集合合并到根节点较小的集合,这样保证最后的根节点的$ID$最小.

人的$ID$是$4$位数,则需枚举$0001\sim 9999$,可用一个bool数组标记每个$ID$是否出现过,或存在set中.

每个人有$1$个父亲、$1$个母亲和至多$5$和孩子,则每个节点至多有$7$条边,$1000$个人最多$7000$条边.

代码

const int MAXN = 1e4 + 5;
int n;  // 人数
int fa[MAXN];  // 并查集的fa[]数组
int people[MAXN], house[MAXN], area[MAXN];  // 人数、房产数、房产面积
set<int> ids;  // 出现过的ID
struct Edge { int u, v; }edges[MAXN];
struct Family {
	int id, people, house, area;  // 最小ID、人数、房产数、房产面积

	bool operator<(const Family& p)const {
		// 以人均房产面积降序排序,即比较area/people和p.area/p.people
		// 交叉相乘可避免浮点数比较
		if (area * p.people != p.area * people) return area * p.people > p.area * people;
		else return id < p.id;  // 人均房产面积相等,以ID升序排序
	}
};

int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

int main() {
	for (int i = 0; i < MAXN; i++) fa[i] = i, people[i] = 1;  // 初始时每个家庭有1个人
	
	cin >> n;

	int m = 0;  // 边数
	for (int i = 0; i < n; i++) {
		int id, father, mother, k; cin >> id >> father >> mother >> k;
		ids.insert(id);
		if (~father) edges[m++] = { id,father };
		if (~mother) edges[m++] = { id,mother };
		for (int j = 0; j < k; j++) {  // 孩子
			int son; cin >> son;
			edges[m++] = { id,son };
		}
		cin >> house[id] >> area[id];
	}

	for (int i = 0; i < m; i++) {
		int u = edges[i].u, v = edges[i].v;
		ids.insert(u), ids.insert(v);

		u = find(u), v = find(v);
		if (u != v) {  // 将u的集合合并到v的集合中
			if (u < v) swap(u, v);  // 保证v的ID小
			people[v] += people[u], house[v] += house[u], area[v] += area[u];
			fa[u] = v;
		}
	}

	vector<Family> families;  // 存每个集合的根节点
	for (auto item : ids)  // 只遍历出现过的ID
		if (fa[item] == item) families.push_back({ item,people[item],house[item],area[item] });
	
	sort(all(families));
	cout << families.size() << endl;
	for (auto item : families)
		printf("%04d %d %.3lf %.3lf\n",
			item.id, item.people, (double)item.house / item.people, (double)item.area / item.people);
}

---

---

10.3 森林里的鸟 ($0.15\mathrm{s}$)

题意

有很多照片,假设同一张照片上的鸟属于同一棵树.求森林中树的最大数量.给定一对鸟,判断它们是否在同一棵树上.

第一行输入包含整数$n(1\le n\le 1\mathrm{e}4)$表示照片数.接下来$n$行每行描述一张照片,格式为$k{B}_1\cdots B_k$,其中$k$表示照片中鸟的数量,$B_i(1\le i\le k\le 10)$表示鸟的编号.数据保证所有照片中的鸟被连续编号$1$到某个不超过$1\mathrm{e}4$的整数.接下来一行输入一个询问数$q(1\le q\le 1\mathrm{e}4)$,接下来$q$行每行输入两个鸟的编号,表示一组询问.

第一行输出森林中树的最大数量和鸟的数量.接下来$q$行对每个询问,若被询问的两鸟在同一棵树上,输出"YES";否则输出"NO".

思路

森林中的树有最大数量的解释:极端情况时照片是一棵树的不同角度.

为了使树的数量最多,合并集合时只合并必须合并的集合.

代码

const int MAXN = 1e4 + 5;
int n;  // 照片数
int fa[MAXN];
int birds[MAXN];  // 临时存一张照片中的鸟的编号
set<int> ids;  // 出现过的id

int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

int main() {
	for (int i = 0; i < MAXN; i++) fa[i] = i;
	
	cin >> n;
	int merge = 0;  // 合并次数
	for (int i = 0; i < n; i++) {
		int k; cin >> k;
		for (int j = 0; j < k; j++) {
			cin >> birds[j];
			ids.insert(birds[j]);
		}

		for (int j = 1; j < k; j++) {  // 每次合并相邻两堆鸟,把前一堆合并到后一堆中
			int a = birds[j - 1], b = birds[j];
			a = find(a), b = find(b);
			if (a != b) {
				fa[a] = b;
				merge++;
			}
		}
	}

	cout << ids.size() - merge << ' ' << ids.size() << endl;  // 树数、鸟数

	CaseT{
		int a,b; cin >> a >> b;
		cout << (find(a) == find(b) ? "Yes" : "No") << endl;
	}
}

---

---

10.4 社会集群 ($1.2\mathrm{s}$)

题意

社会集群指一群有共同爱好的人.假设爱好有传递性.给定社交网络中的人的兴趣爱好,找到所有社会集群.

第一行输入一个$n(1\le n\le 1000)$表示社交网络人数,人编号$1\sim n$.接下来$n$行每行包含一个人的爱好信息,格式为$kh[1]\cdots h[k]$,其中$k$为爱好数,$h[i](1\le i\le k\le n,k>0)$为第$i$个爱好的编号.

第一行输出社会集群数.第二行按非增序输出每个集群的人数.

代码

const int MAXN = 1005;
int n;  // 人数
vi hobbies[MAXN];  // 每个人的爱好
int fa[MAXN];
int people[MAXN];  // 每个集群的人数

int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

int main() {
	for (int i = 0; i < MAXN; i++) fa[i] = i;
	
	cin >> n;
	for (int i = 0; i < n; i++) {
		int k; scanf("%d:", &k);
		while (k--) {
			int h; cin >> h;
			hobbies[h].push_back(i);
		}
	}
	
	for (int i = 1; i <= 1000; i++) {
		for (int j = 1; j < hobbies[i].size(); j++) {
			int a = hobbies[i][0], b = hobbies[i][j];
			fa[find(a)] = find(b);  // 把爱好都合并到后一个
		}
	}
	
	int ans = 0;  // 集群数
	for (int i = 0; i < n; i++) {
		if (!people[find(i)]) ans++;  // 更新集群数
		people[find(i)]++;  // 更新每个集群的人数
	}
	cout << ans << endl;
	
	sort(people, people + n, greater<int>());
	cout << people[0];
	for (int i = 1; i < ans; i++) cout << ' ' << people[i];
	cout << endl;
}

---

---

5. 线段树与树状数组

5.1 动态求连续区间和

题意

给定一个整数数组,数组下标从$1$开始,要求支持两种操作:①修改某一元素的值;②求子序列$[a,b]$的和.

第一行输入两个整数$n(1\le n\le 1\mathrm{e}5)$和$m(1\le m\le 1\mathrm{e}5)$,分别表示数组长度和操作个数.第二行输入$n$个数表示原数组.接下来$m$行每行输入三个数$k,a,b(1\le a\le b\le n)$,当$k=0$是表示求子序列$[a,b]$的和;$k=1$时表示第$a$个数加$b$.数据保证任意时刻数组内的元素之和在int内.

输出$k=0$的操作的结果.

代码

const int MAXN = 1e5 + 5;
int n, m;  // 数组长度、操作数
int BIT[MAXN];

void add(int x, int v) {  // arr[x]+=v
	for (int i = x; i <= n; i += lowbit(i)) BIT[i] += v;
}

int query(int x) {  // 求arr[1...x]的前缀和
	int res = 0;
	for (int i = x; i; i -= lowbit(i)) res += BIT[i];
	return res;
}

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		int x; cin >> x;
		add(i, x);
	}

	while (m--) {
		int k, a, b; cin >> k >> a >> b;
		if (k) add(a, b);
		else cout << query(b) - query(a - 1) << endl;
	}
}

---

---

5.2 数星星 ($0.2\mathrm{s}$)

题意

天上有一些星星,任两个星星位置不同,每个星星有坐标.若一个星星的左下方(含正左和正下)有$k$颗星星,则称该星星是$k$级的.

第一行输入一个整数$n(1\le n\le 1.5\mathrm{e}4)$,表示星星的个数.接下来$n$行输入星星的坐标$(x,y)(0\le x,y\le 3.2\mathrm{e}4)$.数据保证无星星重叠,星星坐标按$y$升序给出,$y$相等时按$x$升序给出.

输出$n$行,第$i(0\le i\le n-1)$行输出一个数表示$i$级的星星的个数.

思路

因输入按$y$升序、$x$升序给出,则在当前点$(x,y)$的左下方的点只能是在其之前输入的点,即只需考虑之前输入的点中有多少个点的横坐标小于等于$x$,亦即求横坐标范围为$[0,x]$的星星的个数.用$a[i]$表示横坐标为$i$的点的个数,则$x$级星星的个数为$a[1]+\cdots +a[x]$.添加一个星星时,只需将对应横坐标的点的个数$+1$.先查询输入的点的左下方的星星个数,再将其插入BIT中,以免将自己也算进去.总时间复杂度$O(n\log n)$.

因输入的坐标$x$从$0$开始,而BIT的下标从$1$开始,可整体加一个偏移量.

代码

const int MAXN = 3.2e4 + 5;
int n;  // 星星数
int BIT[MAXN];
int ans[MAXN];  // 每个等级的星星个数

void add(int x) {
	for (int i = x; i < MAXN; i += lowbit(i)) BIT[i]++;
}

int query(int x) {
	int res = 0;
	for (int i = x; i; i -= lowbit(i)) res += BIT[i];
	return res;
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		int x, y; cin >> x >> y;
		x++;  // 下标从1开始
		ans[query(x)]++;  // 更新该横坐标的点数
		add(x);  // 将该点的横坐标插入BIT
	}

	for (int i = 0; i < n; i++) cout << ans[i] << endl;
}

---

---

25.3.3 公约数的和

例题

给定$n(2\le n\le 2\mathrm{e}6)$,求$\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)$.

思路

[定理1] $\sum _{i\le n}\sum _{d\mid i}\mu (d)=\sum _{d\le n}\lfloor \frac{n}{d}\rfloor \mu (d)$.

[证] $\sum _{i\le n}\sum _{d\mid i}$表示先枚举$1\sim n$内的$i$,再枚举$i$的所有约数,

这等价于先枚举$1\sim n$内的$d$,再枚举其在$1\sim n$内的倍数,显然倍数有$\lfloor \frac{n}{d}\rfloor$个.

[定理2] ∑ i ≤ n ∑ j ≤ m [ gcd ⁡ ( i , j ) = = 1 ] = ∑ d ≤ min ⁡ { n , m } μ ( d ) ⌊ n d ⌋ ⌊ m d ⌋ \displaystyle\sum_{i\leq n}\sum_{j\leq m}[\gcd(i,j)==1]=\sum_{d\leq\min\{n,m\}}\mu(d)\left\lfloor\dfrac{n}{d}\right\rfloor\left\lfloor\dfrac{m}{d}\right\rfloor i≤n∑​j≤m∑​[gcd(i,j)==1]=d≤min{n,m}∑​μ(d)⌊dn​⌋⌊dm​⌋.

[证] 注意到$[\gcd (i,j)==1]=\sum _{d\mid \gcd (i,j)}\mu (d)$,

由定理1:$\mathrm{L}\mathrm{H}\mathrm{S}=\sum _{i\le n}\sum _{j\le m}\sum _{d\mid \gcd (i,j)}\mu (d)=\sum _{i\le n}\sum _{j\le m}\sum _{d\mid i}\sum _{d\mid j}\mu (d)=\sum _{i\le n}\sum _{d\mid i}\sum _{j\le m}\sum _{d\mid j}\mu (d)$.

由定理2: = ∑ d ≤ n ⌊ n d ⌋ ∑ d ≤ m ⌊ m d ⌋ μ ( d ) = ∑ d ≤ min ⁡ { n , m } μ ( d ) ⌊ n d ⌋ ⌊ m d ⌋ \displaystyle =\sum_{d\leq n}\left\lfloor\dfrac{n}{d}\right\rfloor\sum_{d\leq m}\left\lfloor\dfrac{m}{d}\right\rfloor\mu(d)=\sum_{d\leq\min\{n,m\}}\mu(d)\left\lfloor\dfrac{n}{d}\right\rfloor\left\lfloor\dfrac{m}{d}\right\rfloor =d≤n∑​⌊dn​⌋d≤m∑​⌊dm​⌋μ(d)=d≤min{n,m}∑​μ(d)⌊dn​⌋⌊dm​⌋.

为求$\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)$,先求$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)$.

考虑枚举$d\in [1,n]$,则$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)$等于$d$乘$\gcd (i,j)=d$的数的个数,即$\sum _{d\le n}d\cdot \sum _{i\le n}\sum _{j\le n}[\gcd (i,j)==d]$.

$\sum _{d\le n}d\cdot \sum _{i\le n}\sum _{j\le n}[\gcd (i,j)==d]=\sum _{d\le n}d\cdot \sum _{i\le \lfloor \frac{n}{d}\rfloor }\sum _{j\le \lfloor \frac{n}{d}\rfloor }[\gcd (i,j)==1]\stackrel{t=\frac{n}{d}}{=}\sum _{d\le n}d\cdot \sum _{d^{\prime }\le t}\mu (d^{\prime }){\lfloor \frac{t}{d^{\prime }}\rfloor }^2$,用整除分块求即可.

对比$\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)$和$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)$枚举的$(i,j)$对:

	$\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)$	$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)$
$i=1$	$j=2,3,\cdots ,n$	$j=1,2,\cdots ,n$
$i=2$	$j=3,4,\cdots ,n$	$j=1,2,\cdots ,n$
$⋮$	$⋮$	$⋮$
$i=n-1$	$j=n$	$j=1,2,\cdots ,n$
$i=n$	$\varnothing$	$j=1,2,\cdots ,n$

观察知:第$1\sim (n-1)$行后者都比前者多枚举了一倍,且后者比前者多了$i=n$的枚举.

$i=n$时,$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)=\sum _{j\le n}\gcd (n,j)=1+2+\cdots +n=\frac{n(n+1)}{2}$,这是因为$n$是$1\sim n$中最大的,则 gcd ⁡ ( j , n ) = min ⁡ { j , n }    ( 1 ≤ j ≤ n ) \gcd(j,n)=\min\{j,n\}\ \ (1\leq j\leq n) gcd(j,n)=min{j,n}  (1≤j≤n).

故$\sum _{i\le n}\sum _{j\le n}\gcd (i,j)=2\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)+\frac{n(n+1)}{2}$.

代码

const int MAXN = 2e6 + 5;
int n;
int primes[MAXN], cnt = 0;
bool vis[MAXN];
int mu[MAXN];
int pre[MAXN];  // mu[]的前缀和

void init() {  // 预处理mu[]及其前缀和
	mu[1] = 1;
	for (int i = 2; i < MAXN; i++) {
		if (!vis[i]) primes[cnt++] = i, mu[i] = -1;
		for (int j = 0; primes[j] * i < MAXN; j++) {
			vis[primes[j] * i] = true;
			if (i % primes[j] == 0) break;
			mu[primes[j] * i] = -mu[i];
		}
	}
	
	for (int i = 1; i < MAXN; i++) pre[i] = pre[i - 1] + mu[i];
}

ll cal(int n, int d) {
	n /= d;
	ll res = 0;
	for (int l = 1, r = 0; l <= n; l = r + 1) {
		int tmp = n / l;
		r = min(n, n / tmp);
		res += (ll)(pre[r] - pre[l - 1]) * tmp * tmp;  // 注意ll
	}
	return res;
}

int main() {
	init();

	cin >> n;
	ll ans = 0;
	for (int d = 1; d <= n; d++) ans += (ll)d * cal(n, d);

	ans -= (ll)n * (n + 1) / 2, ans >>= 1;
	cout << ans;
}

---

25.3.4 YY的GCD ($4\mathrm{s}$)

例题

有$t(1\le t\le 1\mathrm{e}4)$组测试数据.每组测试数据给定$n,m(1\le n,m\le 1\mathrm{e}7)$,求$1\le x\le n,1\le y\le m$且$\gcd (x,y)$为素数的$(x,y)$的对数.

思路

不妨设$n\le m$,若不然则交换.设素数$k(2\le k\le n)$.

$\sum _{i=1}^n\sum _{j=1}^m[\gcd (i,j)\in primes]=\sum _{k=1}^n\sum _{i=1}^n\sum _{j=1}^m[gcd(i,j)==k]=\sum _{k=1}^n\sum _{i=1}^{\lfloor \frac{n}{k}\rfloor }\sum _{j=1}^{\lfloor \frac{m}{k}\rfloor }[\gcd (i,j)==1]$

​ $=\sum _{k=1}^n\sum _{i=1}^{\lfloor \frac{n}{k}\rfloor }\sum _{j=1}^{\lfloor \frac{m}{k}\rfloor }\sum _{d\mid \gcd (i,j)}\mu (d)$.

先枚举$d$,因$d\mid \gcd (i,j)$,则$i$和$j$都是$d$的倍数.不妨将$i$和$j$的枚举上限都除以$d$,相当于将$i$变为$\lfloor \frac{i}{d}\rfloor \cdot d$,将$j$变为$\lfloor \frac{j}{d}\rfloor \cdot d$.

$原式=\sum _{k=1}^n\sum _{d=1}^{\lfloor \frac{n}{k}\rfloor }\mu (d)\cdot \lfloor \frac{n}{kd}\rfloor \lfloor \frac{m}{kd}\rfloor \stackrel{T=kd}{=}\sum _{T=1}^n\lfloor \frac{n}{T}\rfloor \lfloor \frac{m}{T}\rfloor \cdot \sum _{k\mid T,k\in primes}\mu \left(\frac{T}{k}\right)$.

上式的$\sum _{k\mid T,k\in primes}\mu \left(\frac{T}{k}\right)$可预处理,用一个数组$f[]$记录素数及其倍数累加的$\mu$值,即对每个素数$k$,将其在范围内的所有倍数$T$的$f$值加$\mu \left(\frac{T}{k}\right)$,再求$f[]$的前缀和$pre[]$即可.

代码

const int MAXN = 1e7 + 5;
int n;
int primes[MAXN], cnt = 0;
bool vis[MAXN];
int mu[MAXN];
int f[MAXN];  // 记录素数及其倍数累加的mu值
int pre[MAXN];  // f[]的前缀和

void init() {
	mu[1] = 1;
	for (int i = 2; i < MAXN; i++) {
		if (!vis[i]) primes[cnt++] = i, mu[i] = -1;
		for (int j = 0; primes[j] * i < MAXN; j++) {
			vis[primes[j] * i] = true;
			if (i % primes[j] == 0) break;
			mu[primes[j] * i] = -mu[i];
		}
	}
	
	for (int i = 0; i < cnt; i++) {  // 枚举素数
		for (int j = 1; primes[i] * j <= 1e7; j++)  // 枚举倍数
			f[primes[i] * j] += mu[j];
	}

	for (int i = 1; i < MAXN; i++) pre[i] = pre[i - 1] + f[i];
}

int main() {
	init();

	CaseT{
		int n,m; cin >> n >> m;
		ll ans = 0;
		if (n > m) swap(n, m);  // 保证n≤m

		for (int l = 1, r = 0; l <= n; l = r + 1) {
			r = min(n / (n / l), m / (m / l));
			ans += (ll)(pre[r] - pre[l - 1]) * (n / l) * (m / l);
		}
		cout << ans << endl;
	}
}

---

---

常见的完全积性函数:$ϵ(n)=[n==1],I(n)=1,Id(n)=n$.

对两个数论函数$f$和$g$,定义它们的Dirichlet卷积$(f\ast g)(n)=\sum _{d\mid n}f(d)g\left(\frac{n}{d}\right)$.

性质:①交换律:$f\ast g=g\ast f$;②结合律$(f\ast g)\ast h=f\ast (g\ast h)$;③单位元为$ϵ$,即$f\ast ϵ=ϵ\ast f=f$.

常用结论:

①$\mu \ast I=ϵ$.

​ [证] $u\ast I=\sum _{d\mid n}\mu (d)I\left(\frac{n}{d}\right)=\sum _{d\mid n}\mu (d)=[n==1]=ϵ$.

②$\phi \ast I=Id(n)$.

​ [引理] $\sum _{d\mid n}\phi (d)=n$.

​ [引.证] 考察与$n$的$\gcd$分别为$1,2,\cdots ,n$的数的个数.

​ $\gcd (n,i)=1$的$i$有$\phi (n)$个,$\gcd (n,i)=2$的$i$有$\phi \left(\frac{n}{2}\right)$个,$\cdots$.共$n$个数,故$\sum _{d\mid n}\phi (d)=n$.

​ [证] $\phi \ast I=\sum _{d\mid n}\phi (d)I\left(\frac{n}{d}\right)=\sum _{d\mid n}\phi (d)=n=Id(n)$.

③$Id\ast \mu =\phi (n)$.

​ [证] ②两边卷$\mu$得:$\phi (n)\ast I\ast \mu =Id\ast \mu$,则$\phi (n)\ast (I\ast \mu )=Id\ast \mu$,即$\phi (n)=Id\ast \mu$.

[Mobius反演] 若$f(n)=\sum _{d\mid n}g(d)$,即$f=g\ast I$,则$g(n)=\sum _{d\mid n}f\left(\frac{n}{d}\right)\ast \mu (d)$,即$g=f\ast \mu$.

[证] $f\ast \mu =g\ast I\ast \mu =g\ast ϵ=g$.

---