[HDNOIP2017提高组]题解

Posted 2020-10-08 xjr_01

（送给外省的同学们：HD = 海淀）

 

[HDNOIP201701]小鱼干

试题描述

小喵喵有 n 个小鱼干排成一列，其中第 i 个小鱼干有两种属性，美味度 a_i 和特殊度 b_i。

现在小喵喵要吃掉一些小鱼干，出于一些原因，小喵喵会吃掉连续的一段区间中的所有小鱼干。

如果吃掉了 [l,r] 一段区间，那么小喵喵会获得一些满意度。

形式化地，总满意度 =(∑a_i(i∈[l, r]))×(1+∑b_i(i∈[l, r]))。

由于只有小喵喵最喜欢的小鱼干的特殊度等于 1，所以 b_i=1 的小鱼干数量不会超过 400 个，其他的 b_i=0。

现在小喵喵可以选择任意一段区间（可以为空），但是有一些小鱼干的美味度是负数，吃掉所有小鱼干不一定会获得最多的满意度。所以小喵喵想知道最大能获得的总满意度是多少。

输入

第一行一个整数 n，表示小鱼干的数量。

第二行 n 个整数，第 i 个数为 a_i，表示美味度。

第三行 n 个整数，第 i 个数为 b_i，表示特殊度。

输出

一行一个整数，表示最大的总满意度。

输入示例

5
4 -2 2 -3 1
0 0 1 0 0

输出示例

8

数据规模及约定

对于 60% 的数据，1≤N≤1000。

对于另外 20% 的数据，所有 b_i=0。

对于另外 10% 的数据，保证 b_i=0 的 i 不会超过 20。

对于 100% 的数据，1≤N≤100000，0≤|a_i|≤109，0≤b_i≤1，保证 b_i=1 的 i 不会超过 400。、

题解

关注到 b_i = 1 的 i 的个数不会超过 400，而且我们选择的仅仅是一个区间，所以可以想到枚举最左边和最右边的 1。于是对于每个 b_i = 1 的位置 i，预处理一下 mxl[i] 表示从 i-1 向左到上一个 b 的值为 1 的位置这段区间中的最大后缀和；mxr[i] 表示 i+1 向右到下一个 b 的值为 1 的位置这段区间中的最大前缀和。那么假设我们枚举的最左边的 1 的位置是 a，最右边的 1 的位置是 b，用 (mxl[a] + S[b] - S[a-1] + mxr[b])(b - a + 1) 这个值更新答案即可。注意最后再用整个序列的最大连续和更新一下答案。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == ‘-‘) f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - ‘0‘; c = getchar(); }
	return x * f;
}

#define maxn 100010
#define LL long long

int n, A[maxn], pos[maxn], cntp;
LL S[maxn], mxl[maxn], mxr[maxn], f[maxn][2];

int main() {
	n = read();
	for(int i = 1; i <= n; i++) S[i] = S[i-1] + (A[i] = read());
	for(int i = 1; i <= n; i++) if(read()) pos[++cntp] = i;
	
	LL ans = 0;
	if(cntp) {
		pos[0] = 0; pos[cntp+1] = n + 1;
		for(int i = 1; i <= cntp; i++) {
			LL tmp = 0;
			for(int j = pos[i] - 1; j > pos[i-1]; j--) tmp += A[j], mxl[i] = max(mxl[i], tmp);
			tmp = 0;
			for(int j = pos[i] + 1; j < pos[i+1]; j++) tmp += A[j], mxr[i] = max(mxr[i], tmp);
		}
		for(int i = 1; i <= cntp; i++)
			for(int j = i; j <= cntp; j++)
				ans = max(ans, (mxl[i] + S[pos[j]] - S[pos[i]-1] + mxr[j]) * (j - i + 2));
	}
	for(int i = 1; i <= n; i++)
		f[i][0] = max(f[i-1][0], f[i-1][1]),
		f[i][1] = max(f[i-1][1], 0ll) + A[i];
	ans = max(ans, max(f[n][0], f[n][1]));
	
	printf("%lld\n", ans);
	
	return 0;
}

 

[HDNOIP201702]拓扑排序

试题描述

绵羊送给小喵喵了 n 个小鱼干。小喵喵要把它们全部吃掉！

但是绵羊告诉小喵喵要按照某种顺序来吃。

绵羊一共说了 m 条限制，每条限制的格式为 u v ，表示要先吃掉 u 号小鱼干之后才能吃 v 号小鱼干。

绵羊保证，这些条限制不会出现循环需求的情况，即一定存在某种顺序使得 n 个小鱼干都被吃掉。

绵羊还允许小喵喵不遵守其中小于等于 k 条限制。

小喵喵想知道在吃完所有的小鱼干的前提下，吃小鱼干的顺序的字典序最小是多少。

两个吃小鱼干的顺序的字典序大小比较即为：首先比较第一个吃的小鱼干，编号较小的字典序较小，若相同，则比较第二个吃的小鱼干，一直比到可以分出大小。

注意到两个顺序一定可以比较大小。

输入

第一行为 3 个整数 N、M、K。

第二行至第 M+1 行每行两个正整数 u_i、v_i，表示 u_i 和 v_i 有限制关系，即 u_i 要比 v_i 先吃。

输出

仅一行 N 个正整数，为最优的吃小鱼干的顺序，相邻两个整数之间以空格隔开。

输入示例

5 5 2
3 2
4 3
5 4
3 1
4 1

输出示例

1 5 4 3 2

数据规模及约定

对于 30% 的数据，1≤N、M≤8。

对于 60% 的数据，1≤N、M≤20。

对于另外 30% 的数据，K=0。

对于 100% 的数据，1≤N、M≤152501，1≤u_i、v_i≤N，0≤K≤M。

题解

“字典序最小”，一定先想贪心。

从前往后确定拓扑序上每一位是否可以是当前编号最小的节点，对于节点 u，如果它能放在拓扑序当前为上，须要满足其入度 ≤ K；找到了一个符合条件的 u，则将该节点删除，该节点连出的边也删除。

用一个堆模拟上面的过程就行了，注意我们只用在最初时和每次删除边的时候将节点插入堆中，所以至多插入 n+m 个元素。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <queue>
using namespace std;

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == ‘-‘) f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - ‘0‘; c = getchar(); }
	return x * f;
}

#define maxn 152510
#define oo 2147483647

int n, m, K, head[maxn], nxt[maxn], to[maxn], ind[maxn];

void AddEdge(int a, int b) {
	to[++m] = b; nxt[m] = head[a]; head[a] = m; ind[b]++;
	return ;
}

priority_queue <int> Q;

int main() {
	n = read(); int M = read(); K = read();
	for(int i = 1; i <= M; i++) {
		int a = read(), b = read();
		AddEdge(a, b);
	}
	
	for(int i = 1; i <= n; i++) if(ind[i] <= K) Q.push(-i);
	for(int i = 1; i <= n; i++) {
		int u = -Q.top(); Q.pop();
		while(ind[u] > K) u = -Q.top(), Q.pop();
		printf("%d%c", u, i < n ? ‘ ‘ : ‘\n‘);
		K -= ind[u]; ind[u] = oo;
		for(int e = head[u]; e; e = nxt[e]) if(ind[to[e]] < oo && --ind[to[e]] <= K) Q.push(-to[e]);
	}
	
	return 0;
}

 

 [HDNOIP201703]收集珠宝

试题描述

喵国有 n 个村镇，由 n?1 条无向道路连通。来自喵哈哈村的小喵喵想要周游各地。

旅途的路非常漫长，小喵喵决定在路上买一些宝石收藏，其中第 i 个村镇的宝石价格为 A_i。

小喵喵的策略是这样的：在一个起点村落购买宝石，之后路上如果当前的村落的宝石价格比小喵喵手上最贵的宝石贵，那么小喵喵就会购买当前村落的宝石。

现在小喵喵有 q 次独立的旅行（即进行新的一次旅行时手上的宝石都会消失），小喵喵想知道如果从 u 村落沿最短路旅行到 v 村落会购买多少次宝石。

输入

第一行为 1 个正整数 N。

第二行为 N 个正整数 A_i。

第三行至第 N+1 行每行两个正整数 x_i、y_i，表示 x_i 和 y_i 之间有一条道路。

第 N+2 行为一个正整数 Q。

接下来 Q 行每行一个正整数 u_i、v_i，表示一次询问。

输出

Q 行每行一个正整数，表示答案。

输入示例

5
4 2 2 3 1
1 2
1 3
3 4
3 5
4
1 1
4 2
5 4
1 5

输出示例

1
2
3
1

数据规模及约定

对于 20% 的数据，1≤N、Q≤2501。

对于另外 15% 的数据，所有u_i=1。

对于另外 15% 的数据，所有v_i=1。

对于另外 40% 的数据，1≤N、Q≤152501，所有y_i=x_i+1。

对于 100% 的数据，1≤N、Q≤252501，1≤A_i≤10⁹，1≤u_i、v_i、x_i、y_i≤N。

题解

首先将询问拆成两部分，一段上行，一段下行；对于询问 (u, v)（即从 u 到 v，令 c = u 和 v 的最近公共祖先），拆成 (u, c)（上行）和 (c, v)（下行）。

我们发现就是找这样一条链上单调栈的大小。如果把它变成一个序列问题，即查询区间内单调栈的大小，这个问题就可以用线段树解决。

具体是这样的：我们令 query(node, val) 表示对于线段树节点 node 所对应的区间第一个元素 ≥ val 的单调栈的大小，分两种情况考虑：

1. node->l.maxv <= val，即左边的所有值都小于等于 val，直接跳过左半边，返回 query(node->r, val)

2. node->l.maxv > val，返回 node.size - (node->l.size - query(node->l, val) )，其中 node.size 表示节点 node 所对应区间的单调栈的大小，node->l.size - query(node->l, val) 表示左节点单调栈中小于 val 的部分，所以要减去

maxv 不用说了，size 如何维护？我们只需要写一个 update() 函数即可。update() 函数中，设当前节点为 node

1. 如果当前是叶节点，直接将 node.size 设为 1

2. 否则 node.size = node->l.size + query(node->r, node->l.maxv)，即左边的单调栈肯定是直接拼上来，右边就是从左边最大值开始的单调栈

这个线段树还需要支持区间查询，实现方法类似，留个读者思考。

下面我们需要把一条链转换成一个序列，好在拆解询问后，每条链都是“儿子 - 祖先”的，所以可以 dfs，然后动态地在线段树中进行修改即可。

注意，求 lca 要用树链剖分，因为要保证空间线性！（注：此题空间限制 64MB）

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == ‘-‘) f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - ‘0‘; c = getchar(); }
	return x * f;
}

#define maxn 252510
#define maxm 505020
#define maxlog 18

int n, A[maxn], m, head[maxn], nxt[maxm], to[maxm];

void AddEdge(int a, int b) {
	to[++m] = b; nxt[m] = head[a]; head[a] = m;
	swap(a, b);
	to[++m] = b; nxt[m] = head[a]; head[a] = m;
	return ;
}

int dep[maxn], siz[maxn], fa[maxn], son[maxn], top[maxn];
void build(int u) {
	siz[u] = 1;
	for(int e = head[u]; e; e = nxt[e]) if(to[e] != fa[u]) {
		dep[to[e]] = dep[u] + 1;
		fa[to[e]] = u;
		build(to[e]);
		siz[u] += siz[to[e]];
		if(!son[u] || siz[to[e]] > siz[son[u]]) son[u] = to[e];
	}
	return ;
}
void gett(int u, int tp) {
	top[u] = tp;
	if(son[u]) gett(son[u], tp);
	for(int e = head[u]; e; e = nxt[e]) if(to[e] != fa[u] && to[e] != son[u]) gett(to[e], to[e]);
	return ;
}
int lca(int a, int b) {
	while(top[a] != top[b]) {
		if(dep[top[a]] < dep[top[b]]) swap(a, b);
		a = fa[top[a]];
	}
	return dep[a] < dep[b] ? a : b;
}

struct Que {
	int a, b, c, trn, res;
	Que() {}
	Que(int _, int __): a(_), b(__), c(lca(_, __)) {}
} qs[maxn];
int q;

int mxv[maxn<<2], ssiz[maxn<<2];
int query(int o, int l, int r, int v) {
	if(l == r) return mxv[o] > v;
	int mid = l + r >> 1, lc = o << 1, rc = lc | 1;
	if(v >= mxv[lc]) return query(rc, mid + 1, r, v);
	return ssiz[o] - ssiz[lc] + query(lc, l, mid, v);
}
void update(int o, int l, int r, int p, int v) {
	if(l == r) mxv[o] = v, ssiz[o] = 1;
	else {
		int mid = l + r >> 1, lc = o << 1, rc = lc | 1;
		if(p <= mid) update(lc, l, mid, p, v);
		else update(rc, mid + 1, r, p, v);
		mxv[o] = max(mxv[lc], mxv[rc]);
		ssiz[o] = ssiz[lc] + query(rc, mid + 1, r, mxv[lc]);
	}
	return ;
}
struct Snode { // Segment_tree node
	int o, l, r;
	Snode() {}
	Snode(int _1, int _2, int _3): o(_1), l(_2), r(_3) {}
} qnode[maxlog<<2];
int cntq;
void getqnode(int o, int l, int r, int ql, int qr) {
	if(ql <= l && r <= qr) qnode[++cntq] = Snode(o, l, r);
	else {
		int mid = l + r >> 1, lc = o << 1, rc = lc | 1;
		if(ql <= mid) getqnode(lc, l, mid, ql, qr);
		if(qr > mid) getqnode(rc, mid + 1, r, ql, qr);
	}
	return ;
}
int _v;
int ask(int ql, int qr, int v) {
	cntq = 0; getqnode(1, 1, n, ql, qr);
	int res = 0;
	for(int i = 1; i <= cntq; i++)
		res += query(qnode[i].o, qnode[i].l, qnode[i].r, v),
		v = max(v, mxv[qnode[i].o]);
	_v = v;
	return res;
}

struct QOT { // Queries On Tree
	int head[maxn], nxt[maxn];
	void clear() {
		memset(head, 0, sizeof(head));
		return ;
	}
	void AddQ(int u, int qid) {
		nxt[qid] = head[u]; head[u] = qid;
		return ;
	}
} qt;
int segpos[maxn];
void dfs1(int u, int pos) {
	segpos[u] = pos;
	update(1, 1, n, pos, A[u]);
	for(int e = qt.head[u]; e; e = qt.nxt[e])
		qs[e].res = ask(pos, segpos[qs[e].c], A[qs[e].a] - 1),
		qs[e].trn = _v;
	for(int e = head[u]; e; e = nxt[e]) if(to[e] != fa[u]) dfs1(to[e], pos - 1);
	return ;
}
void dfs2(int u, int pos) {
	segpos[u] = pos;
	update(1, 1, n, pos, A[u]);
	for(int e = qt.head[u]; e; e = qt.nxt[e])
		qs[e].res += ask(segpos[qs[e].c], pos, qs[e].trn);
	for(int e = head[u]; e; e = nxt[e]) if(to[e] != fa[u]) dfs2(to[e], pos + 1);
	return ;
}

int main() {
	n = read();
	for(int i = 1; i <= n; i++) A[i] = read();
	for(int i = 1; i < n; i++) {
		int a = read(), b = read();
		AddEdge(a, b);
	}
	
	build(1);
	gett(1, 1);
	q = read();
	for(int i = 1; i <= q; i++) {
		int u = read(), v = read();
		qs[i] = Que(u, v);
		qt.AddQ(u, i);
	}
	dfs1(1, n);
	memset(mxv, 0, sizeof(mxv));
	memset(ssiz, 0, sizeof(ssiz));
	qt.clear();
	for(int i = 1; i <= q; i++) qt.AddQ(qs[i].b, i);
	dfs2(1, 1);
	
	for(int i = 1; i <= q; i++) printf("%d\n", qs[i].res);
	
	return 0;
}