前言：
pts:25 + 20 + 0 + 30 = 75
最惨淡的一场。
出现的主要问题是没分配好时间，导致 (T3) 的暴力都没来急写。
出现的最大问题是脑子掉线。。。。
今后考试策略：
拿到题先读完所有的题，然后把所有能写的暴力全敲完之后再来想正解。
考试一定要带脑子 ！！！
T1 牛表
题目描述
给出三个整数 ({x,y,P(1le x,y<P)}), ({P}) 为素数，可以重复对 ({x}) 执行如下操作：
选择一个整数 ({zin[1,P-1]}) ，花费 ({|x-z|}) 的牛币，使得 (x=x imes zmod P)。
最小需要花费多少牛币才能使得 ({x=y}) ?
设 ({ans(i,j)}) 为当 ({x=i,y=j}) 时的答案，为了减少输出，你需要输出
({sumlimits_{i=1}^{P-1}sumlimits_{j=1}^{P-1}ans(i,j)*t^{(i-1)*(P-1)+j-1}mod 998244353})
数据范围
(2 leq P leq 2000)
考试的时候真没忘建图那方面想，然后就草草打了个暴力走人了。
solution
对于每一个操作，相当于从 (x) 向 (x * z mod P) 建一条边权为 (|x - z|) 的边，然后到 (y) 跑一个最短路就好了。
30pts
当 (P leq 500) 直接 (Floyed) 就好了。
但由于数据水或者牛客神机太快了，这玩意赛时能过 (85) ，现在加强了数据，但是还能过 (75) 分，就挺反人类行为的 = =
code
/*
work by:Ariel_
Sorce:
Knowledge:
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#define rg register
#define int long long
using namespace std;
const int mod = 998244353;
const int MAXN = 2020, MAXX = 4e6 + 5;
int read(){
int x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
int dis[MAXN][MAXN], Pow[MAXX], p, t, ans;
signed main(){
p = read(), t = read();
memset(dis, 0x3f, sizeof dis);
for (int i = 1; i < p; i++) {
for (int j = 1; j < p; j++) {
int v = i * j % p;
dis[i][v] = min(dis[i][v], abs(i - j));
}
}
for (int i = 0; i < p; i++) dis[i][i] = 0;
for (int k = 0; k < p; k++){
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
Pow[0] = 1;
for (int i = 1; i <= p * p; i++) Pow[i] = Pow[i - 1] * t % mod;
for (int i =1; i < p; i++) {
for (int j = 1; j < p; j++) {
ans = ans + dis[i][j] * Pow[(i - 1) * (p - 1) + j - 1] % mod;
ans %= mod;
}
}
cout<<ans;
return 0;
}
T2 牛牛和数组操作
题目描述
有 (n + 2) 个整数 (a_0, a_1, dots, a_n, a_{n + 1})
你需要做确切地 (n) 次操作，每次操作以下形式：
选择一个整数 (x) 满足 (a_x eq 0), 使得 (a_x)， 令 (l = max_{i < x, a_i = 0}(i), r = min_{i > x, a_i = 0}(i))
此次操作的操作为 (max{a_l, a_{l + 1}, dots, a_{x - 1}} + max{a_{x + 1},dots, a_{r - 1}, a_r}) 牛币
有多少不同的操作方式使得操作花费的牛币最少，两种操作不同当且仅当两种操作的操作序列不同。
答案对 ({998244353}) 取模。
数据范围
(1 leq T leq 10)， 每个测试点 (|n|) 的和 (leq 10000000)
solution
这道题我的 n! 过掉了 (n = 20) 的数据就挺反人类的 = =
这道题 (n^3) 能过也挺反人类的 = =。
正解是个卡常。。。。
10pts
枚举全排列就好了。
20pts
状态压缩，计算代价，对比代价，得出答案。
70pts(实测 90)
设第一个操作的人的编号为 (x)， 在 (x) 进行操作 ([1,x−1]) 和 ({[x+1,n]}) 的操作就独立了，这两段区间进行操作不会对另一段区间的价值产生影响，因此可以进行区间 ({dp})。
设 (f_{l, r}) 表示对 (l, r) 区间进行操作的最小代价。
显然 (f_{l, r} = min{f_{l, k - 1} + f_{k + 1, r}})
设 (g_{l, r}) 为 ([l, r]) 区间内最小操作的序列数量，枚举断点 (k)。
显然只有当 (f_{l, r} = f_{l, k - 1} + f_{k +1, r}) 才可以转移。
(g_{l, r} = g_{l, r} + g_{l, k - 1} imes g_{k +1, r} imes C_{r - l}^{k - l})
因为两个序列之间的操作顺序先后都可，所以就有 (C_{r - l}^{k - l}) 种方案。
复杂度： (n^3)
code
/*
work by:Ariel_
Sorce:
Knowledge:Dp
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
#define int long long
#define rg register
using namespace std;
const int MAXN = 2010, INF = 1e18;
const int mod = 998244353;
int read(){
int x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
int n, C[MAXN][MAXN], a[MAXN], Max[MAXN][MAXN], f[MAXN][MAXN], g[MAXN][MAXN];
void Pre() {
for (int i = 1; i <= n; i++){
Max[i][i] = a[i];
for (int j = i + 1; j <= n; j++)
Max[i][j] = max(Max[i][j - 1], a[j]);
}
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1, C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
void Dp() {
for (int len = 0; len <= n; len++) {
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
if(l >= r) f[l][r] = 0, g[l][r] = 1;
else {
f[l][r] = INF, g[l][r] = 0;
for (int k = l; k <= r; k++)
f[l][r] = min(f[l][r], f[l][k - 1] + f[k + 1][r] + Max[l][k - 1] + Max[k + 1][r]);
for (int k = l; k <= r; k++) {
if(f[l][r] == f[l][k - 1] + f[k + 1][r] + Max[l][k - 1] + Max[k + 1][r])
g[l][r] = (g[l][r] + g[l][k - 1] * g[k + 1][r] % mod * C[r - l][k - l] % mod) % mod;
}
}
}
}
}
signed main(){
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
Pre();
Dp();
cout<<g[1][n];
puts("");
return 0;
}
100pts
实际上每次先操作区间最大值是最优的，因此没有必要对区间的所有数都进行枚举，而只枚举区间最大值，时间复杂度 (O(n^3))
code
/*
work by:Ariel_
Sorce:
Knowledge:
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
#define int long long
#define rg register
using namespace std;
const int mod = 998244353, INF = 1e18;
const int MAXN = 1e3 + 50;
int read(){
int x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
int inv[MAXN], fac[MAXN], g[MAXN][MAXN], f[MAXN][MAXN], Max[MAXN][MAXN];
int pos[MAXN][MAXN], a[MAXN], n;
int nxt[MAXN], pre[MAXN];
bool vis[MAXN][MAXN];
void Pre() {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= 1000; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
for (int i = 2; i <= 1000; i++)
inv[i] = inv[i] * inv[i - 1] % mod;
}
int C(int n, int m) {
if(n < m) return 0;
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
void dfs(int l, int r) {
if(l >= r) {
f[l][r] = 0, g[l][r] = 1;
return ;
}
if(vis[l][r]) return ;
vis[l][r] = true;
f[l][r] = INF, g[l][r] = 0;
for (int i = pos[l][r]; i <= r; i = nxt[i]) {
dfs(l, i - 1), dfs(i + 1, r);
g[l][r] = (g[l][r] + g[l][i - 1] * g[i + 1][r] % mod * C(r - l, i - l) % mod) % mod;
}
}
signed main(){
Pre();
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n + 1; i++) pre[i] = n + 1;
for (int i = n; i >= 1; i--) {
nxt[i] = pre[a[i]];
pre[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
pos[i][i] = i;
for (int j = i + 1; j <= n; j++) {
if(a[pos[i][j - 1]] < a[j]) pos[i][j] = j;
else pos[i][j] = pos[i][j - 1];
}
}
dfs(1, n);
printf("%lld
", g[1][n]);
puts("");
return 0;
}
100pts
对于一段区间 ([l,r])，如果存在 ({a_i=a_{i+1}=maxlimits_{i=l}^r(a_i)(iin[l,r))})
此时 (i, i + 1) 谁先选择没有关系，因此有 (g_{l, r} = g_{l, i - 1} imes g_{i + 1, r} imes C_{r - l + 1}^{i - l + 1})
因此当碰到两个最大值连续出现时，直接将整个区间划分为两段，最大值不连续则仍然枚举所有最大值。
时间复杂度 (O(n^3))
T3 与巨
定义无穷序列 ({f：f_1=1,f_{n}=f_{n-1}*2+1})
定义函数 ({G(x)=minlimits_{f_ige x}(f_i})) ({dp_{c,0}=0,dp_{c,i}=max(dp_{c,i-1},[((i*c)&G(i))==i]*i)})
其中 ({[p]}) 为真值函数，当 ({p}) 为真返回 ({1})，否则返回 ({0})。
求 ({sumlimits_{i=0}^ndp_{c,i}}mod 998244353)
数据范围
(1 leq T leq 10) 每个测试点 (|n|) 的和 (leq 10000000)
solution
20pts
直接模拟题意就好。
/*
work by:Ariel_
Sorce:
Knowledge:
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
#define int long long
#define rg register
using namespace std;
const int mod = 998244353;
const int MAXN = 1e7 + 8;
int read(){
int x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
int T, n, c, f[MAXN];
char s[MAXN];
int G(int x) {
int ret = 0;
while(x) {ret++, x >>= 1;}
return (1 << ret) - 1;
}
signed main(){
T = read();
while(T--) {
scanf("%s%lld", s + 1, &c);
n = 0;
for (int i = 1; i <= s[i]; i++) n = n * 2 + s[i] - '0';
int Ans = 0;
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1];
if(((i * c) & G(i)) == i) f[i] = i;
}
for (int i = 1; i <= n; i++)Ans = (Ans + f[i]) % mod;
cout<<Ans<<"
";
}
puts("");
return 0;
}
100pts
设 (G(i) = 2^{t + 1} - 1) ((G(x))必然是这样的形式，其中 (t) 为 (i) 二进制的最高位)，则 (x & G(i)) 相当于 (xmod 2^{t + 1})，则：((i imes c) & G(i) = i ightarrow (i imes c) mod 2^{t + 1} = i ightarrow i imes (c - 1) mod 2^{t + 1} = 0)
设 (c - 1 = 2^p imes x)，则 (i) 需要含有因子 (2^{t + 1 - p})。
设 (m = |n|)，我们可以枚举 (t)， 如果 (t < m - 1) 则 ([2^t, 2^{t + 1} - 1]) 内的所有数最高位都为 (t)，设 (g = t + 1 - p)， (i) 含有因子 (2^g) 即 (i) 的低于 (g) 位的全为 (0)，这样的数为 (2^t, 2^t + 2^g, dots, 2^t + x imes 2^g(2^t + (x + 1) imes 2^g = 2^{t + 1})), 这是个 (x + 1) 项的等差数列，很容易求和，同时每个数对答案贡献了 (2^g) 次。
当 (t = m - 1) 时，由于 (2^{t + 1} > n), 我们需要满足，(2^t + x imes 2^g leq n ightarrow x = lfloor frac{n}{2^g} floor - 2^{t - g})，对这个 (x + 1) 项的等差数列计算贡献后，由于最后一项被计数了 (2^g) 次（计数范围为([2^t + x imes 2^g, 2^t + (x + 1) imes 2^g - 1])），此时多计数了 (2^t + (x + 1) imes 2^g - 1 - n) 次，把这个贡献减掉就好了。
时间复杂度 (O(n))
code
/*
work by:Ariel_
Sorce:
Knowledge:
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
#define ll long long
#define rg register
using namespace std;
const int MAXN = 1e7 + 5;
const int mod = 998244353;
ll read(){
ll x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
ll pow[MAXN], c, T, n, p;
char s[MAXN];
ll calc(ll s, ll d, ll n) {
return (s * n % mod + d * n % mod * (n + mod - 1) % mod * (mod - mod / 2) % mod) % mod;
}
int main(){
pow[0] = 1;
for (int i = 1; i <= MAXN - 1; i++) pow[i] = (pow[i - 1] << 1) % mod;
T = read();
while(T--){
scanf("%s%lld", s + 1, &c);
n = strlen(s + 1);
c -= 1;
ll Ans = 0;
if(c == 0){
for (int i = 1; i <= n; i++) Ans = ((Ans << 1) + s[i] - '0') % mod;
Ans = Ans * (Ans + 1) % mod * (mod - mod / 2) % mod;
printf("%lld
", Ans);
continue;
}
if(c & 1) {puts("0"); continue;}
p = 0;
while(c % 2 == 0) p++, c /= 2;
for (int t = 0; t < n; t++) {
int g = max(0ll, t + 1 - p);
if(t < n - 1) //正好的时候
Ans = (Ans + pow[g] * calc(pow[t], pow[g], (pow[t + 1 - g] + mod - pow[t - g])) % mod);
else {//计算剩余部分
ll tot = 0;
for (int i = 1; i <= n - g; i++) tot = ((tot << 1) + s[i] - '0') % mod;
tot = (tot + 1 + mod - pow[t - g]) % mod;
Ans = (Ans + pow[g] * calc(pow[t], pow[g], tot)) % mod;
ll res = (pow[t] + (tot + mod - 1) * pow[g] % mod) % mod;
ll l = 0;
for (int i = 1; i <= n; i++) l = ((l << 1) + s[i] - '0') % mod;
int r = (res + pow[g] + mod - 1) % mod;
Ans = (Ans + mod - (r + mod - l) % mod * res % mod) % mod;
}
}
printf("%lld
", Ans);
}
puts("");
return 0;
}
100pts
T4 矩阵学说
题目描述
给出 ({n}) 行 ({m}) 列的矩阵，第 ({i}) 行第 ({j}) 列的元素为 ({a_{i,j}}) ，找出满足以下条件的三元组{(i,j,x)}(i,j,x)的数量：
- ({1le ile n,1le jle m,1le xle min(n-i+1,m-j+1) })
- 矩阵的左上角 ({(i,j)}) 到右下角 ({(i+x-1,j+x-1)}) 恰好含有 ({k}) 个不同的整数。
数据范围
(1 leq k leq n imes m, 1 leq a[i]leq 100)
solution
用 (bitset) 记录颜色种类。
在边长扩展的过程中，不同数量的数只会增加不会减少，具有单调性。于是可以二分找到不同数量 ({<k}) 的最大边长 ({x}) 和不同数量 ({le k}) 的最大边长 ({y})，({y-x}) 即为固定一个左上角符合条件的正方形的数量。
这样需要处理 ({O(n^2logn)}) 个查询，每个查询查询一个正方形内不同颜色的数量，由于是正方形，故可以采用二维 ({st}) 表来做。
code
/*
work by:Ariel_
Sorce:
Knowledge:
Time:
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <bitset>
#define ll long long
#define rg register
using namespace std;
const int MAXN = 1510;
int read(){
int x = 0,f = 1; char c = getchar();
while(c < '0'||c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {x = x*10 + c - '0'; c = getchar();}
return x*f;
}
int n, m, k, lg[MAXN];
bitset<100>f[14][MAXN][MAXN];
void ST(){
for (int k = 1; (1 << k) <= max(n, m); k++)
for (int i = 1; i + (1 << k) - 1 <= n; i++)
for (int j = 1; j + (1 << k) - 1 <= m; j++)
f[k][i][j] = f[k - 1][i][j] | f[k - 1][i + (1 << k - 1)][j] | f[k - 1][i + (1 << k - 1)][j + (1 << k - 1)] | f[k - 1][i][j + (1 << k - 1)];
}
int Query(int x_1, int y_1, int x_2, int y_2) {
int k = lg[x_2 - x_1 + 1];
return (f[k][x_1][y_1] | f[k][x_2 - (1 << k) + 1][y_2 - (1 << k) + 1] | f[k][x_1][y_2 - (1 << k) + 1] | f[k][x_2 - (1 << k) + 1][y_1]).count();
}
ll work(int k) {
if(k == 0) return 0;
ll Ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int l = 1, r = min(n - i + 1, m - j + 1), ret;
while(l <= r) {
int mid = (l + r + 1) >> 1;
if(Query(i, j, i + mid - 1, j + mid - 1) <= k) ret = mid, l = mid + 1;
else r = mid - 1;
}
Ans += ret;
}
}
return Ans;
}
int main(){
for(int i = 1; i < MAXN; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i), lg[i - 1]--;
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) {
for (int j = 1, x; j <= m; j++) {
x = read();
f[0][i][j][x - 1] = 1;
}
}
ST();
printf("%lld", work(k) - work(k - 1));
puts("");
return 0;
}