从这里开始
A < B < E < D < C = F，心情简单.jpg。
Problem A ><
把峰谷都设成 0。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 5e5 + 5;
int n;
char s[N];
int L[N], R[N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1) + 1;
for (int i = 1; i <= n; i++)
L[i] = (s[i - 1] == '<') * (L[i - 1] + 1);
for (int i = n; i; i--)
R[i] = (s[i] == '>') * (R[i + 1] + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += max(L[i], R[i]);
// cerr << max(L[i], R[i]) << ' ';
}
printf("%lld
", ans);
return 0;
}
Problem B Two Contests
考虑如果两个区间有包含，要么它们放在一起，要么长的那一个单独在一场考试。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 1e5 + 5;
const int inf = (signed) (~0u >> 2);
typedef class Segment {
public:
int l, r;
Segment() { }
Segment(int l, int r) : l(l), r(r) { }
Segment operator & (Segment b) const {
return Segment(max(l, b.l), min(r, b.r));
}
int length() {
return max(r - l + 1, 0);
}
boolean operator < (Segment b) const {
return r < b.r;
}
} Segment;
int n;
Segment s[N], sl[N], sr[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &s[i].l, &s[i].r);
}
sort(s + 1, s + n + 1);
int ans = 0;
sl[0] = Segment(0, inf);
for (int i = 1; i <= n; i++)
sl[i] = sl[i - 1] & s[i];
sr[n + 1] = Segment(0, inf);
for (int i = n; i; i--)
sr[i] = sr[i + 1] & s[i];
for (int i = 1; i < n; i++)
ans = max(ans, sl[i].length() + sr[i + 1].length());
for (int i = 1; i <= n; i++)
ans = max(ans, s[i].length() + (sl[i - 1] & sr[i + 1]).length());
printf("%d
", ans);
return 0;
}
Problem C Neither AB nor BA
考虑把奇数位置上的 A 变成 B，B 变成 A，那么现在变成只有 AA 和 BB 不能消除。
考虑能够消除所有字符的必要条件是 A 或者 B 的数量不超过 $n / 2$。不难发现这个条件也是充分的。
如果不存在 C，那么直接消除 AB 即可。
考虑如果 C 只与 A 或者 B 相邻，那么先把 AB 相互消除，最后和 C 消除，如果还剩一些 C，那么把 C 两两消除。因为 A，B 的数量都不超过 $n / 2$，所以它们相互消除后剩下的字符数量不会超过 C 的数量。
否则如果 A，B 的数量一样多，那么至少有 2 个 C，消除 1 个 AC 和 1 个 BC，否则把 C 和较多一个字符消除。显然这样仍然满足条件，可以递归到 $n$ 更小的问题。
然后直接计数就行了。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
#define ll long long
void exgcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1, y = 0;
} else {
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
}
int inv(int a, int n) {
int x, y;
exgcd(a, n, x, y);
return (x < 0) ? (x + n) : (x);
}
const int Mod = 998244353;
template <const int Mod = :: Mod>
class Z {
public:
int v;
Z() : v(0) { }
Z(int x) : v(x){ }
Z(ll x) : v(x % Mod) { }
friend Z operator + (const Z& a, const Z& b) {
int x;
return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
}
friend Z operator - (const Z& a, const Z& b) {
int x;
return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
}
friend Z operator * (const Z& a, const Z& b) {
return Z(a.v * 1ll * b.v);
}
friend Z operator ~(const Z& a) {
return inv(a.v, Mod);
}
friend Z operator - (const Z& a) {
return Z(0) - a;
}
Z& operator += (Z b) {
return *this = *this + b;
}
Z& operator -= (Z b) {
return *this = *this - b;
}
Z& operator *= (Z b) {
return *this = *this * b;
}
friend boolean operator == (const Z& a, const Z& b) {
return a.v == b.v;
}
};
Z<> qpow(Z<> a, int p) {
Z<> rt = Z<>(1), pa = a;
for ( ; p; p >>= 1, pa = pa * pa) {
if (p & 1) {
rt = rt * pa;
}
}
return rt;
}
typedef Z<> Zi;
const int N = 1e7 + 7;
int n;
Zi fac[N], _fac[N], pw2[N];
Zi comb(int n, int m) {
return (n < m) ? (0) : (fac[n] * _fac[m] * _fac[n - m]);
}
int main() {
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i;
_fac[n] = ~fac[n];
for (int i = n; i; i--)
_fac[i - 1] = _fac[i] * i;
pw2[0] = 1;
for (int i = 1; i <= n + 1; i++)
pw2[i] = pw2[i - 1] + pw2[i - 1];
Zi ans = qpow(3, n);
for (int i = (n >> 1) + 1; i <= n; i++)
ans -= comb(n, i) * pw2[n - i + 1];
printf("%d
", ans.v);
return 0;
}
Problem D Balance Beam
一道贪心题就有 100 种假贪心。
假设我们已经定好了顺序，设 $B_i - A_i$ 的前缀 max 为 $mx$，显然答案可以这样计算
for (int i = 1; i <= n; i++) {
if (sum >= B[i]) {
sum -= B[i];
ans += 1;
} else {
ans += 1.0 * sum / B[i];
break;
}
}
考虑枚举进入 else 语句的 $i$。计算贡献可以分为 3 部分：$[1, i), (i, pmx], (pmx, n]$，其中 $pmx$ 表示前缀 max 的位置。先考虑把所有 $A_i < B_i$ 的平衡木加入 $i$ 之后 $pmx$ 之前，然后考虑把一些移动到 i 之前，不难发现移动的代价为 $max{A_i, B_i}$。排序后二分一下最多能选到哪即可。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
#define ll long long
#define ld long double
template <typename T>
boolean vmax(T& a, T b) {
return (a < b) ? (a = b, true) : (false);
}
const int N = 1e5 + 5;
const ll llf = 1e17;
const int inf = (signed) (~0u >> 2);
ll gcd(ll a, ll b) {
return (b) ? (gcd(b, a % b)) : (a);
}
typedef class Fraction {
public:
ll a, b;
Fraction() : a(0), b(1) { }
Fraction(ll a, ll b) : a(a), b(b) { }
boolean operator < (Fraction B) const {
return ((ld) a) * B.b - ((ld) b) * B.a < 0;
}
boolean operator > (Fraction B) const {
return ((ld) a) * B.b - ((ld) b) * B.a > 0;
}
} Fraction;
#define pii pair<int, int>
typedef class Item {
public:
int a, b, id;
Item() { }
Item(int a, int b, int id) : a(a), b(b), id(id) { }
int maxval() const {
return max(a, b);
}
boolean operator < (Item i) const {
return maxval() < i.maxval();
}
} Item;
int n;
vector<Item> E;
ll _presum[N], *presum;
int main() {
scanf("%d", &n);
ll _sum = 0;
for (int i = 1, a, b; i <= n; i++) {
scanf("%d%d", &a, &b);
E.emplace_back(a, b, i);
_sum += max(b - a, 0);
}
sort(E.begin(), E.end());
Fraction ans (0, 1), I (1, 1);
presum = _presum + 1;
presum[-1] = 0;
for (int i = 0; i < n; i++)
presum[i] = presum[i - 1] + E[i].maxval();
for (int j = 0; j < n; j++) {
ll sum = _sum, ts;
Item& e = E[j];
if (e.a > e.b)
sum += e.b - e.a;
int l = 0, r = n - 1, mid;
#define calc(p) (presum[p] - (p >= j) * e.maxval())
while (l <= r) {
mid = (l + r) >> 1;
ts = calc(mid);
if (ts <= sum) {
l = mid + 1;
} else {
r = mid - 1;
}
}
Fraction tmp (sum - calc(l - 1), e.b);
tmp = min(tmp, I);
tmp.a += tmp.b * (l - (l > j));
ans = max(ans, tmp);
}
ll g = gcd(ans.a, ans.b *= n);
ans.a /= g;
ans.b /= g;
printf("%lld %lld
", ans.a, ans.b);
return 0;
}
Problem E Prefix Suffix Addition
显然可以让前缀加非 0 的位置不相交，后缀加非 0 的位置不相交，并且不会更劣。
问题等价于把原序列拆成两个序列 ${x_i}, {y_i}$，满足
-
$x_0 = y_0 = x_{n + 1} = y_{n + 1} = 0$
- $x_i geqslant 0, y_i geqslant 0, x_i + y_i = a_i$。
要求最小化 $sum [x_i > x_{i + 1}] + [y_i < y_{i + 1}]$。
设 $f_{i, j}$ 表示考虑到序列的第 $i$ 位，$x_i$ 的值为 $j$ 的最小代价。
不难发现两个性质：
- $f_{i, j}$ 的极差小于等于 2
- $f_{i, j}$ 单调不增
然后记录一下分界点，转移二分一下就行了。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 2e5 + 5;
typedef class dp_t {
public:
int v0, p1, p2, a;
dp_t() { }
dp_t(int v0, int p1, int p2, int a) : v0(v0), p1(p1), p2(p2), a(a) { }
int eval(int x, int na) {
#define calc(xls, fold) ((fold) + (xls > x) + (a - xls < na - x))
int rt = calc(0, v0);
if (p1 <= a)
rt = min(rt, calc(p1, v0 - 1));
if (p2 <= a)
rt = min(rt, calc(p2, v0 - 2));
return rt;
}
dp_t trans(int na) {
dp_t rt (0, 0, 0, na);
rt.v0 = eval(0, na);
int l = 0, r = na, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (eval(mid, na) == rt.v0) {
l = mid + 1;
} else {
r = mid - 1;
}
}
rt.p1 = l;
r = na;
while (l <= r) {
mid = (l + r) >> 1;
if (eval(mid, na) == rt.v0 - 1) {
l = mid + 1;
} else {
r = mid - 1;
}
}
rt.p2 = l;
return rt;
}
} dp_t;
int n;
int a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
dp_t f (0, 1, 1, 0);
for (int i = 1; i <= n; i++)
f = f.trans(a[i]);
f = f.trans(0);
printf("%d
", f.v0);
return 0;
}
Problem F Two Pieces
考虑用 $(x, d)$ 来表示一个状态，其中较大数在 $x$，较小数和较大数的差为 $d$。那么可以通过一些限制转化成求操作序列个数，有如下三种操作：
- 将 $x, d$ 同时加上 1
- 将 $d$ 减少 1，这个时候必须满足 $d geqslant 2$
- 将 $d$ 设为 0.
你发现前面两个操作"很 Catalan"，考虑确定前两个操作序列，然后插入第三种操作。
不难发现第 1 种操作会恰好执行 $B$ 次，考虑枚举第 $2$ 种操作的操作次数 $k$。然后能用折线法计算方案数。
如果 $N = B + k$，这种情况很 trivial，可以直接做。否则考虑 $B + k < N$ 的情况。
考虑如何插入第 3 种操作，注意到它插入后必须同时满足两个条件：
- 纵坐标到达 $B - A$。
- 不会使第二种操作不合法。
注意到它的影响相当于把一段后缀的 $d$ 减去其中第一个 $d$ 的值。所以为了满足第二个条件它必须是严格的后缀最小值，为了满足第一个条件它需要操作最后一个 $d = A - k$。
满足这之后，可以把操作 3 插入任意一个满足 $d leqslant A - k$ 的严格后缀最小值处。这个直接插板法算方案即可。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
#define ll long long
void exgcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1, y = 0;
} else {
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
}
int inv(int a, int n) {
int x, y;
exgcd(a, n, x, y);
return (x < 0) ? (x + n) : (x);
}
const int Mod = 998244353;
template <const int Mod = :: Mod>
class Z {
public:
int v;
Z() : v(0) { }
Z(int x) : v(x){ }
Z(ll x) : v(x % Mod) { }
friend Z operator + (const Z& a, const Z& b) {
int x;
return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
}
friend Z operator - (const Z& a, const Z& b) {
int x;
return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
}
friend Z operator * (const Z& a, const Z& b) {
return Z(a.v * 1ll * b.v);
}
friend Z operator ~(const Z& a) {
return inv(a.v, Mod);
}
friend Z operator - (const Z& a) {
return Z(0) - a;
}
Z& operator += (Z b) {
return *this = *this + b;
}
Z& operator -= (Z b) {
return *this = *this - b;
}
Z& operator *= (Z b) {
return *this = *this * b;
}
friend boolean operator == (const Z& a, const Z& b) {
return a.v == b.v;
}
};
Z<> qpow(Z<> a, int p) {
Z<> rt = Z<>(1), pa = a;
for ( ; p; p >>= 1, pa = pa * pa) {
if (p & 1) {
rt = rt * pa;
}
}
return rt;
}
typedef Z<> Zi;
const int N = 2e7 + 7;
int n, A, B;
Zi fac[N], _fac[N];
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i;
_fac[n] = ~fac[n];
for (int i = n; i; i--)
_fac[i - 1] = _fac[i] * i;
}
Zi comb(int n, int m) {
return (n < m) ? (0) : (fac[n] * _fac[m] * _fac[n - m]);
}
Zi calc(int x, int y) {
return comb(x + y, x) - comb(x + y, x + 1);
}
int main() {
scanf("%d%d%d", &n, &A, &B);
if (!B) {
puts("1");
return 0;
}
init(n << 1);
Zi ans = 0;
for (int k = 0; k <= n - B && k <= A; k++) {
if (B + k == n) {
ans += (A == k) * calc(B - 1, A);
} else {
ans += calc(B - 1, k) * comb(n - B - k - 1 + A - k, A - k);
}
}
printf("%d
", ans.v);
return 0;
}