从这里开始
因为比赛的时候在路上，所以又成功错过下分和被神仙 jerome_wei 吊起来打（按在地上摩擦）的好机会。
Problem A Pay to Win
把这个过程倒过来。不难发现到下一次除之前，要么是加到 $lfloor n/d floor d$ 要么是 $lceil n/d ceil d$，或者直接减到 0.
直接用 map 记忆化的复杂度为 $O(T log^3 N log log N)$。具体的来说，每个状态只可能是 $lfloor frac{n}{2^a3^b5^c} floor$ 或者 $lceilfrac{n}{2^a3^b5^c} ceil$，对于 $ leftlceilfrac{lfloor frac{n}{u} floor }{v} ight ceil $ 的情况有 $left lfloorfrac{n}{uv} ight floor = leftlfloorfrac{lfloor frac{n}{u} floor }{v} ight floor leqslant leftlceilfrac{lfloor frac{n}{u} floor }{v} ight ceil leqslant leftlceilfrac{lceilfrac{n}{u} ceil}{v} ight ceil = leftlceilfrac{n}{uv} ight ceil$
Code
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pli pair<ll, int>
template <typename T>
bool vmin(T& a, T b) {
return (a > b) ? (a = b, true) : false;
}
const ll llf = 1e18;
ll n;
int T, A, B, C, D;
map<ll, ll> F;
vector<pair<int, int>> tr;
ll dfs(ll n) {
if (n == 0) {
return 0;
} else if (n == 1) {
return D;
} else if (F.count(n)) {
return F[n];
}
ll ret = llf;
if (n <= ret / D) {
ret = n * D;
}
for (auto t : tr) {
int d = t.first;
int c = t.second;
ll nn = n / d * d;
vmin(ret, dfs(nn / d) + (n - nn) * D + c);
nn = (n + d - 1) / d * d;
vmin(ret, dfs(nn / d) + (nn - n) * D + c);
}
return F[n] = ret;
}
void solve() {
cin >> n >> A >> B >> C >> D;
F.clear();
tr = vector<pair<int, int>> {make_pair(2, A), make_pair(3, B), make_pair(5, C)};
cout << dfs(n) << '
';
}
int main() {
cin >> T;
while (T--) {
solve();
}
return 0;
}
Problem B Joker
容易发现初始最短路之和为 $O(n^3)$。一个人离开后暴力更新会产生改变的位置，时间复杂度不会超过初始最短路之和。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
template <typename T>
T smin(T x) {
return x;
}
template <typename T, typename ...K>
T smin(T a, const K &...args) {
return min(a, smin(args...));
}
const int N = 505;
const int mov[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int n;
int ans = 0;
int f[N][N];
int vis[N][N];
bool occupy[N][N];
queue<int> qx0, qy0, qx1, qy1;
void update(int x, int y) {
static int dfc = 0;
++dfc;
qx0.push(x);
qy0.push(y);
while (!qx0.empty() || !qx1.empty()) {
int ex = -1, ey = -1;
if (!qx0.empty()) {
ex = qx0.front();
ey = qy0.front();
qx0.pop();
qy0.pop();
} else {
ex = qx1.front();
ey = qy1.front();
qx1.pop();
qy1.pop();
}
if (vis[ex][ey] == dfc) {
continue;
}
vis[ex][ey] = dfc;
int w = f[ex][ey] + occupy[ex][ey];
for (int i = 0; i < 4; i++) {
int nx = ex + mov[i][0];
int ny = ey + mov[i][1];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= n && w < f[nx][ny]) {
f[nx][ny] = w;
if (!occupy[ex][ey]) {
qx0.push(nx);
qy0.push(ny);
} else {
qx1.push(nx);
qy1.push(ny);
}
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
f[i][j] = smin(i - 1, j - 1, n - i, n - j);
occupy[i][j] = true;
}
}
for (int i = 1, _ = n * n, t, x, y; i <= _; i++) {
scanf("%d", &t);
x = (t - 1) / n + 1;
y = t - (x - 1) * n;
ans += f[x][y];
occupy[x][y] = false;
update(x, y);
}
printf("%d
", ans);
return 0;
}
Problem C Strange Dance
建一个 Trie 树，维护位置 $i$ 上的是谁。
对于 S 操作就是一个全局交换 2,3 子树。
对于 R 操作做一次循环位移，然后暴力递归有进位的子树。
Code
#include <bits/stdc++.h>
using namespace std;
int ans[540000];
typedef class TrieNode {
public:
TrieNode *ch[3];
bool swp12;
int id;
void swap12() {
swp12 ^= 1;
swap(ch[1], ch[2]);
}
bool leaf() {
return !ch[0];
}
void push_down() {
if (swp12) {
ch[0]->swap12();
ch[1]->swap12();
ch[2]->swap12();
swp12 = false;
}
}
void get_ans(int base, int v) {
if (leaf()) {
ans[id] = v;
return;
}
push_down();
ch[0]->get_ans(base * 3, v);
ch[1]->get_ans(base * 3, v += base);
ch[2]->get_ans(base * 3, v += base);
}
} TrieNode;
TrieNode pool[1000000];
TrieNode *_top = pool;
TrieNode *newnode() {
return _top++;
}
typedef class Trie {
public:
TrieNode* rt;
void build(TrieNode*& p, int r, int base, int v) {
p = newnode();
if (r == 0) {
p->id = v;
return;
}
build(p->ch[0], r - 1, base * 3, v);
build(p->ch[1], r - 1, base * 3, v += base);
build(p->ch[2], r - 1, base * 3, v += base);
}
void build(int n) {
build(rt, n, 1, 0);
}
void swap12() {
rt->swap12();
}
void update(TrieNode*& p) {
if (p->leaf()) {
return;
}
p->push_down();
swap(p->ch[0], p->ch[1]);
swap(p->ch[0], p->ch[2]);
update(p->ch[0]);
}
void update() {
update(rt);
}
void get_ans() {
rt->get_ans(1, 0);
}
} Trie;
int n;
char T[200005];
Trie tr;
int main() {
scanf("%d", &n);
scanf("%s", T + 1);
int m = strlen(T + 1);
tr.build(n);
for (int i = 1; i <= m; i++) {
char c = T[i];
if (c == 'S') {
tr.swap12();
} else {
tr.update();
}
}
tr.get_ans();
int all = 1;
for (int i = 1; i <= n; i++) {
all *= 3;
}
for (int i = 0; i < all; i++) {
printf("%d ", ans[i]);
}
return 0;
}
Problem D Guess the Password
考虑询问 62 次长度为 128 的全 a 串，全 b 串.....然后可以知道每种字符有多少个。
注意到如果有一个长度为 $l$ 的串是原串的子序列，那么如果在这个串中插入一个字符 $c$ 使得询问的结果减少 1，这意味着插入后仍然是原串的子序列。
考虑如果我们已经知道两个字符集不相交的串 $s, t$ 分别是原串的子序列，我们怎么把它们合并。考虑在 $s$ 的每个位置依次插入 $t$ 的下一个未确定字符，然后判断它是否是原串的子序列。
然后做一个简单归并就好了。
Code
#include <bits/stdc++.h>
using namespace std;
int query(string s) {
cout << "? " << s << '
';
cout.flush();
int dis;
cin >> dis;
return dis;
}
int L;
string charset;
vector<string> strs;
string merge(int l, int r) {
if (l == r) {
return strs[l];
}
int mid = (l + r) >> 1;
string sl = merge(l, mid);
string sr = merge(mid + 1, r);
string cur = "";
int should = L - sl.length();
int pr = 0, _pr = (signed) sr.size();
for (int i = 0; i < (signed) sl.size(); i++) {
while (pr < _pr && query(cur + sr[pr] + sl.substr(i)) == should - 1) {
cur += sr[pr++];
should--;
}
cur += sl[i];
}
while (pr < _pr) {
cur += sr[pr++];
}
return cur;
}
int main() {
for (int i = 0; i < 26; i++) {
charset += (char) ('a' + i);
}
for (int i = 0; i < 26; i++) {
charset += (char) ('A' + i);
}
for (int i = 0; i < 10; i++) {
charset += (char) ('0' + i);
}
L = 0;
for (int i = 0; i < 62; i++) {
char c = charset[i];
string s;
int cnt;
s.assign(128, c);
L += (cnt = 128 - query(s));
strs.push_back(s.substr(0, cnt));
}
string ans = merge(0, (signed) strs.size() - 1);
cout << "! " << ans << '
';
cout.flush();
return 0;
}
Problem E Random Pawn
首先假设第一个和最后一个都是 $A$ 中最大的，如果不是这样的话可以通过旋转，然后再在后面增加一个来实现。
因为到 $A$ 最大的地方一定会停止，因此现在问题变成了链上。
设 $E_i$ 表示从 $i$ 出发的最大期望收益，显然有 $E_i = max{frac{E_{i - 1} + E_{i + 1}}{2} - B_i, A_i}$。
考虑有 $B_i$ 非常地难处理，考虑把它搞掉。
设 $F_i = E_i - C_i$，那么有 $F_i = max{frac{E_{i - 1} - C_{i - 1} + E_{i + 1} - C_{i + 1}}{2}+ frac{C_{i - 1} + C_{i + 1}}{2} - C_i - B_i, A_i - C_i}$ 。
因此 $C_i$ 满足 $ frac{C_{i - 1} + C_{i + 1}}{2} - C_i - B_i = 0$。钦定 $C_0 = C_1 = 0$，然后可以简单构造出来。
注意到 $C_{i + 1} - C_i - 2B_i = C_i - C_{i - 1}$ 因此 $C_i$ 大概是 $2B_i$ 做二次前缀和，因此范围大概是 $10^{12}$ 左右。
考虑最终的序列中是硬点若干位置 $p$，使得 $F_p = A_p$。接下来假定 $A_i$ 都已经减去了 $C_i$。
考虑知道一段最左端为 $l$，最右端为 $r$ 时怎么计算中间的贡献。不难发现中间的 $F$ 满足 $F_{i} - F_{i - 1} = F_{i + 1} - F_i$，因此有 $F_i = frac{(i - l) A_r + (r - i) A_l}{r - l}$。
然后求一个和有 $sum_{l <i < r} F_i = frac{1}{2}(A_l + A_r) (r - l - 1)$。
如果答案被计算两次，每一段各计算一次首尾的贡献，最终再计算一次开头和结尾的贡献。
那么此时一段的贡献为 $(A_l + A_r) (r - l)$，不难发现这个是某个梯形面积的两倍。
不难发现取 ${(i, A_i)}$ 的上凸壳的点的时候，这个面积能达到最大值。（因为显然这个时候 $F_i$ 达到了最大值）
Code
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef class Point {
public:
ll x, y;
Point() { }
Point(ll x, ll y) : x(x), y(y) { }
} Point;
Point operator - (Point a, Point b) {
return Point(a.x - b.x, a.y - b.y);
}
ll cross(Point a, Point b) {
return a.x * b.y - a.y * b.x;
}
int n;
int main() {
scanf("%d", &n);
vector<ll> A (n), B (n);
for (auto& x : A) {
scanf("%lld", &x);
}
for (auto& x : B) {
scanf("%lld", &x);
}
int id = 0;
for (int i = 1; i < n; i++) {
if (A[i] > A[id]) {
id = i;
}
}
rotate(A.begin(), A.begin() + id, A.end());
rotate(B.begin(), B.begin() + id, B.end());
A.push_back(A[0]);
B.push_back(B[0]);
vector<ll> C (n + 1, 0);
for (int i = 2; i <= n; i++) {
C[i] = 2 * (C[i - 1] + B[i - 1]) - C[i - 2];
}
int tp = 0;
vector<Point> stk (n + 3);
for (int i = 0; i <= n; i++) {
Point P (i, A[i] - C[i]);
while (tp >= 2 && cross(stk[tp] - stk[tp - 1], P - stk[tp]) >= 0)
tp--;
stk[++tp] = P;
}
ll res = 0;
for (int i = 2; i <= tp; i++) {
res += (stk[i - 1].y + stk[i].y) * (stk[i].x - stk[i - 1].x);
}
res += stk[1].y + stk[tp].y;
for (int i = 0; i <= n; i++) {
res += 2 * C[i];
}
res -= A[0] * 2;
double ans = 1.0 * res / (2 * n);
printf("%.12lf
", ans);
return 0;
}
Problem F Name-Preserving Clubs
假设有 $k$ 个集合，那么考虑建一个 $k imes n$ 的矩阵，每一位填 0 或者 1，表示这个集合中是否包含这个元素。
首先考虑任意两个集合都不同的情况。
如果称一个上述矩阵是好的，那么当且仅当任意打乱它的列（不能和原来相同），不存在一种方式使得打乱行和最初的矩阵相同。不难发现，这和题目中的一个 name-preserving configuration 一一对应。
不难证明一个好的矩阵任意两列都不同，因为如果存在两列相同，我们交换这两列， 它和原来一模一样，这和定义矛盾。
假设一个矩阵 $A$ 是好的，可以注意到下面两个性质：
- $A$ 的转置 $A^{T}$ 是好的。
- 考虑 $2^k$ 种不同的列，由其中所有不存在于 $A$ 的列构成的矩阵 $A^{C}$ 也是好的。
前者如果不成立，那么对应的行列操作可以应用到 $A$ 上使得操作后和它自己相同。因为没有任意一行或者一列是相同的，所以行列都至少操作 1 次，因此这是满足定义的。
注意到行列操作是独立的，因此先打乱行，再打乱列是等价的。
对于后者，考虑如果不成立，那么打乱行后，使得和原来的列集合相同，可以推出，做这些打乱行操作，可以使得 $A$ 不是好的。
推论 设 $c(k, n)$ 表示本质不同的 $k imes n$ 的好的矩阵的数量，那么有 $c(k, n) = c(n, k), c(k, n) = c(k, 2^{k} - n)$
证明由上述讨论易得。
设 $g(n)$ 表示最小的 $k$ 使得 $c(k, n) > 0$，那么有：
性质1 $2^{g(n)} - n geqslant g(g(n))$
证明 不断应用推论可得 $c(g(n), n) = c(g(n), 2^{g(n)} - n) = c(2^{g(n)} - n, g(n))$，然后由定义可得。
设函数 $G(n)$ 满足 $G(1) = 0$，$G(n)$ 是最小的 $k$ 满足 $2^{k} - n geqslant G(k)$。
引理1 对于 $n > 1$，那么有 $0 leqslant G(i) - G(i - 1) leqslant 1$。
证明 首先不难用归纳法证明 $G(i) < i$。然后 $G(i) geqslant G(i - 1)$ 比较显然，这里略去证明。
考虑用归纳法，当 $n = 2,3$ 的时候显然。
考虑 $n = i(i > 3)$ 的情形。因为 $2^{G(i - 1)} - (i - 1) geqslant G(G(i - 1))$，$2^{G(i - 1)} geqslant 2$，所以有 $2^{G(i - 1) + 1} - i geqslant 2^{G(i - 1)} + 1 - (i - 1) geqslant G(G(i - 1)) + 1 geqslant G(G(i - 1) + 1)$ 。
引理2 对于 $k geqslant G(n)$，那么都有 $2^k - n geqslant G(k)$
证明 考虑用归纳法，当 $k = G(n)$ 显然成立。
当 $k > G(n)$ 的时候因为有 $2^{k - 1} geqslant 1$，所以有 $2^{k} - n geqslant 2^{k -1} + 1 - n geqslant G(k - 1) + 1 geqslant G(k)$。
引理3 $c(k, n) > 0$ 当且仅当 $G(n) leqslant k leqslant 2^n - G(n)$。
证明 必要性显然，考虑充分性。
考虑使用归纳法，当 $n = 1$ 的时候显然成立。下面当 $n > 1$ 的时候
如果 $G(n) leqslant k < n$，那么可以用推论使得变为 $k > n$ 的情形。现在我们来证明它满足条件，因为 $k geqslant G(n)$，所以有 $2^k - n geqslant G(k)$，所以有 $n leqslant 2^n - G(k)$。因为 $k leqslant 2^n - G(n)$，所以 $2^n - k geqslant G(n)$，因此 $n geqslant G(k)$，因此有 $G(k) leqslant n leqslant 2^n - G(k)$。
如果 $2^{n - 1} < k$，那么可以用推论使得变为 $k < 2^{n - 1}$ 的情形。我们还是来证明它满足条件，因为 $2^n - k < k$，所以只用证明 $G(n) leqslant 2^n - k$。因为 $2^n - G(n) geqslant k$，移项可得它成立。
现在考虑 $n leqslant k leqslant 2^{n - 1}$。
考虑构造一个集合 ${{1}, {1, 2}, {2, 3}, {3, 4}, cdots, {n - 1, n}}$。然后对于剩下 $k - n$ 个填任意大小大于等于 $3$ 的集合。
可以手动验证当 $n = 2, n = 3$ 可行，当 $n geqslant 4$ 的时候，满足大小大于等于 $3$ 的集合至少占了一半，因此一定可行。
引理4 当 $6 leqslant k leqslant n leqslant 2^{k - 1}$ 时， $c(k, n) > 1000$
证明的思路大概是考虑先构造一个大小为 $k - 2$ 的集合，包含 ${1, 2}, {2, 3}, cdots, {k - 2, k -1}$，然后将其中一个或者其中 $k - 3$ 个取补集。剩下的 $n - k + 2$ 个集合随便塞大小不为 2 或者 $k - 2$ 的集合。
然后考虑两个集合可能相同的情况。由于 yyf 非常菜，目前还不会，所以咕咕咕咕。结论是 $n = 4$ 的时候答案加上 1，$n = 7$ 的时候答案加上 2.
对于剩下 $k leqslant 5, n leqslant 2^{k - 1}$ 的情况写一个爆搜就行了。如果您的爆搜比较慢，请打表。
Code
#include <bits/stdc++.h>
using namespace std;
/*
#include <bits/stdc++.h>
using namespace std;
const int Nmx = 5;
const int fac[6] = {1, 1, 2, 6, 24, 120};
int shuf[Nmx + 1][120][1 << Nmx];
void prepare() {
auto arrange = [&] (int v, int l, const vector<int>& p) {
int rt = 0;
for (auto x : p) {
if (v & 1) {
rt |= 1 << x;
}
v >>= 1;
}
return rt;
};
for (int l = 1; l <= Nmx; l++) {
vector<int> p (l);
for (int i = 0; i < l; i++) {
p[i] = i;
}
for (int id = 0; next_permutation(p.begin(), p.end()); id++) {
for (int i = 0; i < (1 << l); i++) {
shuf[l][id][i] = arrange(i, l, p);
}
}
}
}
bool check(int n, const vector<int>& tb) {
static int vis[1 << Nmx], dfc = 0;
++dfc;
for (auto x : tb) {
vis[x] = dfc;
}
for (int i = 0; i < fac[n] - 1; i++) {
bool flag = true;
for (int j = 0; j < (signed) tb.size() && flag; j++) {
flag = vis[shuf[n][i][tb[j]]] == dfc;
}
if (flag) {
return false;
}
}
return true;
}
int ans = 0;
vector<int> stk;
void dfs(int l, int d, int k, int ls) {
if (d == k) {
ans += check(l, stk);
if (ans > 1000 * fac[l]) {
throw 1;
}
return;
}
for (int s = ls + 1; s < (1 << l); s++) {
stk[d] = s;
dfs(l, d + 1, k, s);
}
}
int n, k;
int table[6][20];
int main() {
prepare();
for (int k = 1; k <= 5; k++) {
for (int n = k; n <= (1 << (k - 1)); n++) {
::k = k;
::n = n;
::ans = 0;
stk.resize(n);
try {
dfs(k, 0, n, -1);
} catch(int) {
ans = 1001 * fac[k];
}
cout << k << " " << n << '
';
ans /= fac[k];
table[k][n] = ans;
}
}
cout << "{{}";
for (int i = 1; i <= 5; i++) {
cout << ",
{";
cout << table[i][0];
for (int j = 1; j <= 16; j++) {
cout << ", " << table[i][j];
}
cout << "}";
}
cout << "};
";
return 0;
}
*/
const int table[6][20] = {{},
{1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 36, 108, 220, 334, 384, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 976, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001}};
#define ll long long
vector<int> G (105);
void prepare() {
G[1] = 0;
for (int n = 2; n <= 100; n++) {
for (int k = 1; k < n; k++) {
if ((1 << k) >= n && ((1 << k) - n) >= G[k]) {
G[n] = k;
break;
}
}
}
}
int g(ll n) {
if (n <= 100) {
return G[n];
}
for (int k = 1; ; k++) {
if ((1ll << k) >= n && ((1ll << k) - n) >= g(k)) {
return k;
}
}
assert(false);
return -1;
}
int solve(ll n, ll k) {
if (n < k) {
swap(n, k);
}
if (k < 63 && (1ll << k) - n < n) {
return solve((1ll << k) - n, k);
}
if (k > 5) {
return 1001;
}
return k == 0 ? 1 : table[k][n];
}
int main() {
ll n;
prepare();
scanf("%lld", &n);
int ans = solve(n, g(n));
ans += (n == 4);
ans += (n == 7) * 2;
printf("%d
", (ans > 1000) ? -1 : ans);
return 0;
}