（送给外省的同学们：HD = 海淀）
[HDNOIP201701]小鱼干
试题描述
小喵喵有 n 个小鱼干排成一列，其中第 i 个小鱼干有两种属性，美味度 ai 和特殊度 bi。
现在小喵喵要吃掉一些小鱼干，出于一些原因，小喵喵会吃掉连续的一段区间中的所有小鱼干。
如果吃掉了 [l,r] 一段区间，那么小喵喵会获得一些满意度。
形式化地，总满意度 =(∑ai(i∈[l, r]))×(1+∑bi(i∈[l, r]))。
由于只有小喵喵最喜欢的小鱼干的特殊度等于 1，所以 bi=1 的小鱼干数量不会超过 400 个，其他的 bi=0。
现在小喵喵可以选择任意一段区间（可以为空），但是有一些小鱼干的美味度是负数，吃掉所有小鱼干不一定会获得最多的满意度。所以小喵喵想知道最大能获得的总满意度是多少。
输入
第一行一个整数 n，表示小鱼干的数量。
第二行 n 个整数，第 i 个数为 ai，表示美味度。
第三行 n 个整数，第 i 个数为 bi，表示特殊度。
输出
一行一个整数，表示最大的总满意度。
输入示例
5 4 -2 2 -3 1 0 0 1 0 0
输出示例
8
数据规模及约定
对于 60% 的数据，1≤N≤1000。
对于另外 20% 的数据，所有 bi=0。
对于另外 10% 的数据，保证 bi=0 的 i 不会超过 20。
对于 100% 的数据，1≤N≤100000，0≤|ai|≤109，0≤bi≤1，保证 bi=1 的 i 不会超过 400。、
题解
关注到 bi = 1 的 i 的个数不会超过 400，而且我们选择的仅仅是一个区间，所以可以想到枚举最左边和最右边的 1。于是对于每个 bi = 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
", ans);
return 0;
}
[HDNOIP201702]拓扑排序
试题描述
绵羊送给小喵喵了 n 个小鱼干。小喵喵要把它们全部吃掉！
但是绵羊告诉小喵喵要按照某种顺序来吃。
绵羊一共说了 m 条限制，每条限制的格式为 u v ，表示要先吃掉 u 号小鱼干之后才能吃 v 号小鱼干。
绵羊保证，这些条限制不会出现循环需求的情况，即一定存在某种顺序使得 n 个小鱼干都被吃掉。
绵羊还允许小喵喵不遵守其中小于等于 k 条限制。
小喵喵想知道在吃完所有的小鱼干的前提下，吃小鱼干的顺序的字典序最小是多少。
两个吃小鱼干的顺序的字典序大小比较即为：首先比较第一个吃的小鱼干，编号较小的字典序较小，若相同，则比较第二个吃的小鱼干，一直比到可以分出大小。
注意到两个顺序一定可以比较大小。
输入
第一行为 3 个整数 N、M、K。
第二行至第 M+1 行每行两个正整数 ui、vi，表示 ui 和 vi 有限制关系，即 ui 要比 vi 先吃。
输出
仅一行 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≤ui、vi≤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 ? ' ' : '
');
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 个村镇的宝石价格为 Ai。
小喵喵的策略是这样的：在一个起点村落购买宝石，之后路上如果当前的村落的宝石价格比小喵喵手上最贵的宝石贵，那么小喵喵就会购买当前村落的宝石。
现在小喵喵有 q 次独立的旅行（即进行新的一次旅行时手上的宝石都会消失），小喵喵想知道如果从 u 村落沿最短路旅行到 v 村落会购买多少次宝石。
输入
第一行为 1 个正整数 N。
第二行为 N 个正整数 Ai。
第三行至第 N+1 行每行两个正整数 xi、yi，表示 xi 和 yi 之间有一条道路。
第 N+2 行为一个正整数 Q。
接下来 Q 行每行一个正整数 ui、vi，表示一次询问。
输出
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% 的数据，所有ui=1。
对于另外 15% 的数据，所有vi=1。
对于另外 40% 的数据，1≤N、Q≤152501，所有yi=xi+1。
对于 100% 的数据，1≤N、Q≤252501，1≤Ai≤109，1≤ui、vi、xi、yi≤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
", qs[i].res);
return 0;
}