题目链接：https://codeforces.com/contest/733
A - Grasshopper And the String
题意：有个虫子，要跳过一个长度为 (n) 的字符串（从 (0) 跳到 (n+1) ），只能停在元音字母处。求最短的跳跃距离。
题解：求前后相邻两个停留位置的差的最大值。
char s[200005];
void test_case() {
scanf("%s", s + 1);
int n = strlen(s + 1);
int lst = 0, maxlen = 0;
for(int i = 1; i <= n; ++i) {
if(s[i] == 'A' || s[i] == 'E' || s[i] == 'I' || s[i] == 'O' || s[i] == 'U' || s[i] == 'Y') {
maxlen = max(maxlen, i - lst);
lst = i;
}
}
maxlen = max(maxlen, n + 1 - lst);
printf("%d
", maxlen);
}
B - Parade
题意：阅兵，第 (i) 行的士兵有 (l_i) 个喜欢先出左脚，有 (r_i) 个喜欢先出右脚。定义阅兵的整齐度为 (|L-R|) ，其中 (L=sum_{i=1}^{n}l_i) ，
(R) 同理。现在可以调整至多一个行的士兵，让他们左右颠倒，求最大的整齐度。
题解：枚举这个行。
int n;
int l[100005];
int r[100005];
void test_case() {
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d%d", &l[i], &r[i]);
ll sumL = 0, sumR = 0;
for(int i = 1; i <= n; ++i) {
sumL += l[i];
sumR += r[i];
}
int ans = 0;
ll cur = abs(sumL - sumR);
ll tsumL = sumL, tsumR = sumR;
for(int i = 1; i <= n; ++i) {
sumL -= l[i];
sumR -= r[i];
sumL += r[i];
sumR += l[i];
ll tmp = abs(sumL - sumR);
if(tmp > cur) {
ans = i;
cur = tmp;
}
sumL = tsumL;
sumR = tsumR;
}
printf("%d
", ans);
}
*C - Epidemic in Monstropolis
题意：给一个数字序列 (a) ，规定每次可以选一个数字可以吃掉相邻的一个比它小的数字。再给一个数字序列 (b) ，求一种可以把 (a) 构造为 (b) 的方法。或者说明无解。
错误算法：数字比较少，只有 (n(1leq nleq 500)) 个。暗示可以搞立方的算法。首先每个 (b_j) 对应的范围是唯一确定的，然后每次规定这一段的最大的一个吃最小的一个数字，假如最大的和最小的相等就GG了。
题解：应该连续段内是不可以交换顺序的，所以按照敦爷的思路，枚举最后一个吃的数字，易知只有这个数字吃别的数字才是最好的，所以对于一个区间可以 (len^2) 枚举。
但是细节还是蛮多的，肯定是贪心取连续的一段 (a_i) 直至越界或超过 (b_j) ，假如此时不为 (b_j) 则无解。除此之外虽然考虑了 (i) 提前用完，但是没有考虑 (j) 提前用完，导致搞了几发。
int n, m;
int a[505], b[505];
bool check_help(int L, int R, int M) {
int l = M - 1, r = M + 1;
int sum = a[M];
while(l >= L || r <= R) {
if(l >= L && r <= R) {
if(a[l] <= a[r]) {
if(sum <= a[l])
return 0;
else {
sum += a[l];
--l;
}
} else {
if(sum <= a[r])
return 0;
else {
sum += a[r];
++r;
}
}
} else if(l >= L) {
if(sum <= a[l])
return 0;
else {
sum += a[l];
--l;
}
} else {
if(sum <= a[r])
return 0;
else {
sum += a[r];
++r;
}
}
}
return 1;
}
pair<int, char> ans[505];
int atop;
void gen(int L, int R, int M, int p) {
//printf("[%d,%d],%d
", L, R, M);
int l = M - 1, r = M + 1;
int sum = a[M];
while(l >= L || r <= R) {
if(l >= L && r <= R) {
if(a[l] <= a[r]) {
sum += a[l];
--l;
ans[++atop] = {M - p, 'L'};
++p;
} else {
sum += a[r];
++r;
ans[++atop] = {M - p, 'R'};
}
} else if(l >= L) {
sum += a[l];
--l;
ans[++atop] = {M - p, 'L'};
++p;
} else {
sum += a[r];
++r;
ans[++atop] = {M - p, 'R'};
}
}
}
bool check(int L, int R, int p) {
for(int m = L; m <= R; ++m) {
if(check_help(L, R, m)) {
gen(L, R, m, p);
return 1;
}
}
return 0;
}
void test_case() {
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
scanf("%d", &m);
for(int j = 1; j <= m; ++j)
scanf("%d", &b[j]);
int i = 1, sum = 0;
atop = 0;
for(int j = 1; j <= m; ++j) {
if(i > n) {
puts("NO");
return;
}
int L = i, R = i;
while(i <= n && sum < b[j]) {
sum += a[i];
R = i;
++i;
}
if(sum != b[j]) {
puts("NO");
return;
}
if(!check(L, R, L - j)) {
puts("NO");
return;
}
sum = 0;
}
if(i <= n) {
puts("NO");
return;
}
puts("YES");
for(int i = 1; i <= atop; ++i)
printf("%d %c
", ans[i].first, ans[i].second);
}
收获：只有移除左侧的元素才会使得中间元素的偏移值变大。注意观察一整段移除元素之后偏移值的变化。以及验证和构造可以分开写，加快常数也减少复杂度。
D - Kostya the Sculptor
题意：找至多两块可以完全贴合（某个面完全一致）的长方体，贴在一起，然后切一个最大的球出来。
题解：考虑要切的是球体，所以受限制的是最短边。所以可以把边排序，把长的两条边作为ID，然后尝试把短边贴在一起，这样有可能会改进答案。所以选个数据结构map就可以。甚至连常数都可以省掉，定义一个struct的前两维是长边，然后按照长边排序，可以贴合的就会排在附近，找出每种前两维相等的struct中最大的两个进行贴合。
int a[3];
map<pair<int, int>, pair<int, int> > M;
void test_case() {
int n;
scanf("%d", &n);
int ansL = 0;
int k = 0;
int k1 = 0, k2 = 0;
for(int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[0], &a[1], &a[2]);
sort(a, a + 3);
pii &tL = M[{a[1], a[2]}];
if(tL.first == 0) {
if(a[0] > ansL) {
ansL = a[0];
k = 1;
k1 = i;
}
tL = {a[0], i};
} else {
int curL = min(a[1], a[0] + tL.first);
if(curL > ansL) {
ansL = curL;
k = 2;
k1 = i;
k2 = tL.second;
}
if(a[0] > tL.first)
tL = {a[0], i};
}
}
printf("%d
", k);
if(k == 1)
printf("%d
", k1);
else
printf("%d %d
", k1, k2);
}
*F - Drivers Dissatisfaction
群友们好像提到NOI魔法森林。
题意：有一个 (n(2leq nleq 2cdot 10^5)) 点 (m(n-1leq mleq 2cdot 10^5)) 边的连通无向边带权图。每条边除了权值 (w_j) 外还带有减少 (w_j) 一个单位的cost (c_j) 。用不超过 (S) 的cost，构造一棵mst。注意边权可以为负数或0。
题解：花钱减少的权值的边肯定是选一条既在mst里面的且单价最便宜的边。所以每条边事实上只有两种状态，原价或者最便宜价。那么枚举每条边作为最便宜的，然后这条边肯定必选，剩下的原价边求一次mst。这个复杂度是 (m^2logm) 。枚举的过程中有可能可以重复利用的就是原价的mst，所以怪不得是LCT。假如得到一棵原价mst，然后加入最便宜边的时候首先若是其原价边本身在mst中则直接计算新贡献即可，否则一定断开这条链上的原价最大值，然后连接最便宜边得到新的（可能的）mst。那么这个并不需要LCT，树剖也可以。但是其实树剖是可以带修改的，这道题不带修改，所以按道理用树剖的思路把一条链断成 (logn) 个连续区间，然后在ST表上面查就可以了。正好备一个树剖ST表。
看见是4秒，可以先写一个树剖线段树。但是最后还是直接树剖ST表过了。
需要注意的细节是，ST表需要传递最值来源于哪里。而且要临时“发明”一个对边树剖。注意对边树剖时，定下根之后除了根以外的每个节点和它与其父亲的边一一对应。在树剖上统计的时候，当在同一重链上时则不计算最高的节点，轻重链交替时要计算最高的节点。
#define lc (o<<1)
#define rc (o<<1|1)
const int MAXN = 200000 + 5;
int dep[MAXN], siz[MAXN], son[MAXN], fa[MAXN], top[MAXN], tid[MAXN], rnk[MAXN], cnt;
int n, m, r, mod;
int a[MAXN];
int head[MAXN], etop;
struct Edge {
int v, next;
int w, i;
} e[MAXN * 2];
inline void init(int n) {
etop = 0;
memset(head, -1, sizeof(head[0]) * (n + 1));
}
inline void addedge(int u, int v, int w, int i) {
e[++etop].v = v;
e[etop].w = w;
e[etop].i = i;
e[etop].next = head[u];
head[u] = etop;
e[++etop].v = u;
e[etop].w = w;
e[etop].i = i;
e[etop].next = head[v];
head[v] = etop;
}
pii faE[MAXN + 5];
struct SparseTable {
static const int MAXLOGN = 19;
static const int MAXN = 200000;
int n, logn[MAXN + 5];
pii f[MAXN + 5][MAXLOGN + 1];
void Init1() {
logn[1] = 0;
for(int i = 2; i <= MAXN; i++)
logn[i] = logn[i >> 1] + 1;
}
void Init2(int _n) {
n = _n;
for(int i = 1; i <= n; i++)
//树剖时应替换本身在线段树中build位置的东西
f[i][0] = faE[rnk[i]];
for(int j = 1, maxlogn = logn[n]; j <= maxlogn; j++) {
for(int i = 1; i + (1 << j) - 1 <= n; i++)
f[i][j] = max(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
pii Query(int l, int r) {
//一个可以返回最大值以及最大值来源（最右）的ST表
int s = logn[r - l + 1];
return max(f[l][s], f[r - (1 << s) + 1][s]);
}
} st;
void init1() {
dep[r] = 1;
}
void dfs1(int u, int t, pii E) {
siz[u] = 1, son[u] = -1, fa[u] = t;
faE[u] = E;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if(v == t)
continue;
dep[v] = dep[u] + 1;
dfs1(v, u, {e[i].w, e[i].i});
siz[u] += siz[v];
if (son[u] == -1 || siz[v] > siz[son[u]])
son[u] = v;
}
}
void init2() {
cnt = 0;
}
void dfs2(int u, int t) {
top[u] = t;
tid[u] = ++cnt;
rnk[cnt] = u;
if (son[u] == -1)
return;
dfs2(son[u], t);
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if(v == fa[u] || v == son[u])
continue;
dfs2(v, v);
}
}
pii CPTQuery(int u, int v) {
pii ret = {-INF, -INF};
int tu = top[u], tv = top[v];
while (tu != tv) {
if(dep[tu] > dep[tv]) {
swap(u, v);
tu = top[u], tv = top[v];
}
//对边树剖，没到同一重链的时候，要算上轻重链交错位置
ret = max(ret, st.Query(tid[tv], tid[v]));
v = fa[tv];
tv = top[v];
}
//对边树剖，已到达同一重链上，不再算上高处的节点对应的边，也就是左区间+1，越界需要返回
if(tid[u] == tid[v])
return ret;
if(dep[u] > dep[v])
swap(u, v);
ret = max(ret, st.Query(tid[u] + 1, tid[v]));
return ret;
}
struct DisjointSetUnion {
static const int MAXN = 200000;
int n, fa[MAXN + 5], rnk[MAXN + 5];
void Init(int _n) {
n = _n;
for(int i = 1; i <= n; i++) {
fa[i] = i;
rnk[i] = 1;
}
}
int Find(int u) {
int r = fa[u];
while(fa[r] != r)
r = fa[r];
int t;
while(fa[u] != r) {
t = fa[u];
fa[u] = r;
u = t;
}
return r;
}
bool Merge(int u, int v) {
u = Find(u), v = Find(v);
if(u == v)
return false;
else {
if(rnk[u] < rnk[v])
swap(u, v);
fa[v] = u;
rnk[u] += rnk[v];
return true;
}
}
} dsu;
struct E2 {
int w, c, u, v, i;
bool operator<(const E2 &e)const {
return w < e.w;
}
} e2[200005];
int ANSI[200005], ANSW[200005];
void test_case() {
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; ++i)
scanf("%d", &e2[i].w);
for(int i = 1; i <= m; ++i)
scanf("%d", &e2[i].c);
for(int i = 1; i <= m; ++i) {
scanf("%d%d", &e2[i].u, &e2[i].v);
e2[i].i = i;
}
//建立原价最小生成树
sort(e2 + 1, e2 + 1 + m);
dsu.Init(n);
init(n);
int cnt = 0;
ll sum = 0;
for(int i = 1; i <= m; ++i) {
if(dsu.Merge(e2[i].u, e2[i].v)) {
addedge(e2[i].u, e2[i].v, e2[i].w, e2[i].i);
sum += e2[i].w;
ANSI[++cnt] = e2[i].i;
ANSW[cnt] = e2[i].w;
if(cnt == n - 1)
break;
}
}
//对最小生成树进行树剖
init1();
int r = 1;
dfs1(r, -1, {-INF, -INF});
init2();
dfs2(r, r);
st.Init1();
st.Init2(n);
//统计答案
ll ans = sum;
int S, eid = -1, aid = -1;
scanf("%d", &S);
for(int j = 1; j <= m; ++j) {
pii ret = CPTQuery(e2[j].u, e2[j].v);
ll tmp = sum - ret.first + e2[j].w - S / e2[j].c;
if(tmp < ans) {
ans = tmp;
eid = ret.second;
aid = j;
}
}
printf("%lld
", ans);
for(int j = 1; j <= n - 1; ++j) {
if(ANSI[j] != eid)
printf("%d %d
", ANSI[j], ANSW[j]);
else
printf("%d %d
", e2[aid].i, e2[aid].w - S / e2[aid].c);
}
return;
}