2022NOIP A层联测20
今天又寄了，本来以为能切三个，结果都挂了
感觉自己太浮躁，而且对于理论上上的东西（复杂度）分析的能力太差
而且非常不长记性，\(long long\) 的问题经常出，还是经常寄。。。。
问问大家有什么好办法防挂吗？
A. 多项式求根
考场做法复杂度假了
考虑由 \(x^n+y^n\) 转移到 \(x^{n+1} + y^{n + 1}\)
\(x^{n + 1} + y^{n + 1} = (x^n + y^n) \times (x + y) - xy(x^{n - 1} + y^{n - 1})\)
于是矩阵快速幂即可
也有递归版的做法， \(chino\)大佬估计会写在他的题解里
code
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 105;
const int mod = 998244353;
ll add, mul, n;
struct matrix{
int a[2][2];
matrix(){memset(a, 0, sizeof(a));}
friend matrix operator *(const matrix &x, const matrix &y){
matrix ans;
for(int i = 0; i < 2; ++i)
for(int k = 0; k < 2; ++k)
for(int j = 0; j < 2; ++j)
ans.a[i][j] = (ans.a[i][j] + 1ll * x.a[i][k] * y.a[k][j] % mod) % mod;
return ans;
}
}ans, x;
int main(){
freopen("poly.in","r",stdin);
freopen("poly.out","w",stdout);
cin >> add >> mul >> n; --n;
for(int i = 0; i < 2; ++i)ans.a[i][i] = 1;
x.a[0][0] = add; x.a[1][0] = mod - mul; x.a[0][1] = 1;
for(; n; n >>= 1, x = x * x)if(n & 1)ans = ans * x;
x.a[0][0] = add; x.a[0][1] = 2; x.a[1][0] = x.a[1][1] = 0;
x = x * ans;
printf("%d\n",x.a[0][0]);
return 0;
}
B. 数三角
如果你能想到正难则反，那么这个题应该会比较好做
如果你还记得开够 \(long long\) 那么就能切掉了
合法的数量难以统计，但是总数是好求的，考虑算出不合法情况减掉
一个不合法的三角形，有两个顶点会连接不同颜色的边，于是对每个顶点计算他作为其中一个不合法顶点的方案数，加起来除以\(2\)即可
code
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = -1;
namespace GenHelper{
unsigned z1, z2, z3, z4, b, u;
unsigned get(){
b = ((z1 << 6) ^ z1) >> 13; z1 = ((z1 & 4294967294U) << 18) ^ b;
b = ((z2 << 2) ^ z2) >> 27; z2 = ((z2 & 4294967288U) << 2) ^ b;
b = ((z3 << 13) ^ z3) >> 21; z3 = ((z3 & 4294967280U) << 7) ^ b;
b = ((z4 << 3) ^ z4) >> 12; z4 = ((z4 & 4294967168U) << 13) ^ b;
return (z1 ^ z2 ^ z3 ^ z4);
}
bool read(){
while (!u) u = get();
bool res = u & 1; u >>= 1;
return res;
}
void srand(int x){
z1 = x; z2 = (~x) ^ 0x233333333U;
z3 = x ^ 0x1234598766U; z4 = (~x) + 51;
u = 0;
}
}
using namespace GenHelper;
bool edge[8005][8005];
int n, seed;
ll cnt[8005];
int main(){
freopen("triangle.in","r",stdin);
freopen("triangle.out","w",stdout);
cin >> n >> seed; srand(seed);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
edge[j][i] = edge[i][j] = read();
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)cnt[i] += edge[i][j];
ll ans = 0;
for(int i = 0; i < n; ++i)ans += cnt[i] * (n - cnt[i] - 1);
ans /= 2;
ans = 1ll * n * (n - 1) * (n - 2) / 6 - ans;
cout << ans << endl;
return 0;
}
C. 棋盘染色
之前有个类似的题元素周期表
这个题是类似的，按照权排序后考虑是否需要染黑当前点即可
考场没有注意值域，忘了想桶排这个东西，于是\(TLE\)了
以及如果你看了我之前写的元素周期表会发现按照同样的做法会 \(TLE\)
之前的做法基本是暴力枚举，虽然复杂度好像正确，但是常数是真的大
转化一下，把每一行每一列都看成一个点，点看成边，实际上我们是在建一棵最小生成树，于是就能切了
code
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 5005;
int n, m;
ll a, b, c, D, p;
vector<pii>v[100001];
int f[maxn + maxn]; int fa(int x){return f[x] == x ? x : f[x] = fa(f[x]);}
int main(){
freopen("color.in","r",stdin);
freopen("color.out","w",stdout);
cin >> n >> m >> a >> b >> c >> D >> p;
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= m; ++j){
a = (a * a * b + a * c + D) % p;
v[a].push_back(pii(i, j));
}
ll ans = 0;
for(int i = 1; i <= n + m; ++i)f[i] = i;
int cnt = n + m;
for(int i = 0; i <= 100000; ++i)
for(pii now : v[i]){
int x = fa(now.first), y = fa(now.second + n);
if(x == y)continue; ans += i; f[y] = x;
}
cout << ans << endl;
return 0;
}
D. 猜数游戏
奇妙，考场不会暴力，不会模拟。。
这种题应该怎么去想，暴力如何去打，大家有什么想法吗
设 \(a_i\) 表示最终答案为 \(i\) 的话，还能撒谎几次，初始为 \(1\)， 如果一次的回答指向了不包含 \(i\) 的一侧，那么 \(--a_{i}\)， 那么当 \(a_{i} < 0\) 时，其一定不能作为当前答案，最终结束条件就是只有一个数大于等于 \(0\)
观察性质可以发现一定是左侧一些 \(0\) 中间一些 \(1\) ，右侧一些 \(0\)，而如果只要步数的话，具体在哪个位置不重要，于是可以设计以下 \(DP\)
\(f_{a, b, c}\)表示 \(0 , 1, 0\) 子序列三部分的长度，转移枚举这次选择在哪里询问，以及回答 \(1 / 0\) ，由于\(A\)策略，两个回答要取 \(max\),由于\(B\)选择询问，那么位置之间是取 \(min\)
那么到这有了 \(40\) 分
40pts
//递归
int dfs(int x, int y, int z){
if(f[x][y][z])return f[x][y][z]; if(x + y + z == 1)return f[x][y][z] = 1;
int ans = 0x3f3f3f3f;
for(int i = 1; i <= x - (z == 0 && y == 0); ++i)ans = min(ans, max(dfs(x - i, y, z), dfs(i , 0, y)) + 1);
for(int i = 1; i <= y - (z == 0); ++i)ans = min(ans, max(dfs(i, y - i, z), dfs(x, i, y - i)) + 1);
for(int i = 1; i < z; ++i)ans = min(ans, max(dfs(y, 0, z - i), dfs(x, y, i)) + 1);
return f[x][y][z] = ans;
}
int main(){
freopen("guess.in","r",stdin);
freopen("guess.out","w",stdout);
cin >> n;
for(int i = 1; i <= n; ++i){
cout << dfs(i - 1, n - i + 1, 0) - 1 << " ";
}
return 0;
}
//迭代，注意枚举顺序
memset(f, 0x3f, sizeof(f));
f[1][0][0] = f[0][1][0] = f[0][0][1] = 1;
for(int len = 2; len <= n; ++len){
for(int y = 0; y <= len; ++y)
for(int z = 0; z <= len - y; ++z){
int x = len - y - z;
for(int i = 1; i <= x - (z == 0 && y == 0); ++i)f[x][y][z] = min(f[x][y][z], max(f[x - i][y][z], f[i][0][y]) + 1);
for(int i = 1; i <= y - (z == 0); ++i)f[x][y][z] = min(f[x][y][z], max(f[i][y - i][z], f[x][i][y - i]) + 1);
for(int i = 1; i < z; ++i)f[x][y][z] = min(f[x][y][z], max(f[y][0][z - i], f[x][y][i]) + 1);
}
}
for(int i = 1; i <= n; ++i){
cout << f[i - 1][n - i + 1][0] - 1 << " ";
}
注意 \(n^3\) 优化这里是我口胡的，正确性没有代码验证，欢迎 \(fake\)
优化考虑选择一个询问位置，从左到右，选择回答 \(1\) 的步数会减少， \(0\) 会增加，中间存在位置是两种方案谁更优的交界点，在这里进行转移即为最优决策
而对于确定的 \(a, b\) 随着 \(c\) 的增大，该位置单调右移，于是可以优化至 \(n^3\)
正解需要一个经典的操作
注意到答案范围较小，交换 \(DP\) 数组的一个下标和答案，转变定义
\(f_{i, m, r}\) 表示操作 \(i\) 步，中间 \(1\) 有 \(m\) 个， 一侧 \(0\) 有 \(r\) 个，另一侧 \(0\) 的最大数量
转移可以对 \(n^4\) 的进行变型，具体可以看代码
解释几个小点
首先左侧 \(0\) 和右侧 \(0\) 是高度对称的，所以转移中有一些可以理解成翻转左右的操作
然后对于确定的 \(m\) ，随着一侧 \(0\) 数量的减少，另外一侧 \(0\) 的最大数量会单调不降，于是可以后缀取 \(max\)
有一说一，难得\(Ly\)讲题讲的这么细（虽然我还是菜的褐代码）
code
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int n, f[19][2005][2005];
int main(){
// freopen("guess.in","r",stdin);
// freopen("guess.out","w",stdout);
cin >> n; memset(f, -0x3f, sizeof(f));
f[0][0][1] = f[0][1][0] = 0; f[0][0][0] = 1;
for(int i = 1; i <= 18; ++i){
for(int m = 0; m <= n; ++m){
for(int r = 0; r <= n - m; ++r){
int l = min(f[i - 1][m][r] + f[i - 1][0][m], n - m);
if(l >= 0)f[i][m][r] = max(f[i][m][r], l), f[i][m][l] = max(f[i][m][l], r);
}//询问一侧0
for(int p = 0; p <= m; ++p){
int q = m - p, l = min(f[i - 1][p][q], n - m), r = min(f[i - 1][q][p], n - m);
if(l >= 0 && r >= 0)f[i][m][r] = max(f[i][m][r], l), f[i][m][l] = max(f[i][m][l], r);
}//询问中间1
for(int j = n; j >= 0; --j)f[i][m][j] = max(f[i][m][j], f[i][m][j + 1]);
}
}
for(int i = 1; i <= n; ++i){
int ans = 0;
while(f[ans][n - i + 1][i - 1] < 0)++ans;
cout << ans << " ";
}
cout << endl;
return 0;
}
