【更新中】2021ZR模拟赛要题记录
ZR模拟赛要题记录
（NOIP十连测、考前二十连测）
姊妹篇：ZR模拟赛未了的心愿
NOIP_Day5_合并石子(Continuing)
将长度都为 n 的 a 和 b 两列石子等概率一一配对求和，求第 k 大期望的石子个数。
求第 K 大的期望，即求出对于任意 \(x\)， 第 K 大的数等于 x 的期望，求和即为答案。
对于每一个 x 来说：
为了求出第 K 大等于 x，我们设：
f_i 表示至少有 i 对小于等于 x 的方案数，
g_i 表示恰好有 i 对小于等于 x 的方案数。
根据二项式反演，有：
g_i = \sum_{j_i} ^ {j <= n} f_j * \binom{j}{i}
第 K 大的数小于等于 x $\Leftrightarrow $ 存在某个 \(k \leq K\)， 恰好有 k - 1 个数大于 x ，其他的数都小于等于x。
dp_{i,j} 表示匹配了a的前i个数，至少存在j对和小于等于x
20连测_Day1_多项式题
设d_i表示前i位的划分权值和，也就是字串[1,i]的答案，相当于从i和i+1之间断开。
发现这种乘积加和满足乘法分配律，也就是对于划分出来的数字[i,j]，\(d_j = d_{i - 1} * num_{i,j}\)，我们并不关心前j位是怎么划分的，而可以直接把\(num_{i,j}\)乘到后面。
\(d_i = \sum_{j = 1} ^ {j < i} d_j * num_{j + 1, i} = \sum_{j = 1} ^ {j < i} (d_j * (mulum[i] - mulum[j] * 10^{i - j})) = \sum(d_j * mulum[i] - d_j * mulum[j] * 10^{i - j})\)
倒序枚举 j 那么\(10^{i-j}\)可以累乘。
前缀和优化, 记:
\(
D_i = \sum_{j = 1} ^ {j <= i} d_i \\
Sj_i = \sum_{j = 1} ^ {j <= i} mulum[j] * Teninv[j] * d[j]
\)
那么 \(d_i = mulum[i] * D_{i - 1} - Ten[i] * Sj_{i - 1}\)
复杂度：\(O(n)\)
int n;
ll d[maxn], mulum[maxn], Ten[maxn], D[maxn], Sj[maxn], Teninv[maxn], inv10;
char s[maxn];
ll ksm(ll bs, int B){
ll res(1);
while(B){
if(B & 1){
res = res * bs % Mod;
}
bs = bs * bs % Mod;
B >>= 1;
}
return res;
}
int main(){
n = rd();
scanf("%s", s + 1);
Teninv[0] = D[0] = Ten[0] = d[0] = 1ll; inv10 = ksm(10, Mod - 2);
for(int i(1); i <= n; ++i) Ten[i] = Ten[i - 1] * 10 % Mod, Teninv[i] = Teninv[i - 1] * inv10 % Mod, mulum[i] = (mulum[i - 1] * 10 + s[i] - '0') % Mod;
for(int i(1); i <= n; ++i){
d[i] = (D[i - 1] * mulum[i] % Mod - Sj[i - 1] * Ten[i] % Mod + Mod) % Mod;
D[i] = D[i - 1] + d[i]; Sj[i] = Sj[i - 1] + mulum[i] * Teninv[i] % Mod * d[i] % Mod;
if(D[i] >= Mod) D[i] -= Mod; if(Sj[i] >= Mod) Sj[i] -= Mod;
}
printf("%lld\n", d[n]);
return 0;
}
20连测_Day2_数集
你需要维护⼀个⼀开始为空的⾮负整数集 S ，⽀持两种操作：
- 向集合 S 种加⼊⼀个数 x;
- 对于⼀个数字 y ，查询\(\max_{x\in S} x op y\) ，其中 op 是与、或、异或三种运算中的某⼏种。
（x 值域是 \(1 ^ 20\)）
- op = xor
用 trie 树维护集合即可。
- op = and
从高位向低位，如果 y 当前位为1，那么我们希望选择这一位为1的数字；
如果 y 当前位为0，无法做出决定。
每当我们遇到无法做出决定的时刻，就不做出决定，也即默认这一位为0。
- op = or
从高位向低位，如果 y 当前位为0，那么我们希望选择这一位为1的数字；
如果 y 当前位为1，无法做出决定，只能为0。
枚举子集
枚举所有的正整数 i ，使得 \(i | x = x\)，方法如下：
for(int i = x; i; i = (i - 1) & x);
注意这里的边界条件是 i != 0, 而不是 i >= 0，如果 i = 0 了， 那么负数做 & 运算会出大问题。
每插入一个数 x, 我们把 vis[] 中 x 的所有子集 i 都置为1，代表与集合 S 内与 y 的按位与、按位或结果可能是 i。
注意: trie 树要开值域乘2，因为 trie 树上第 i 层有 \(2 ^ i\) 个结点，\(\sum_{i=0}^{20} = 2 ^ 21 - 1\)。
代码
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int rd(){
int res = 0, fl = 1; char c = getchar();
while(!isdigit(c)){if(c == '-') fl = -1; c = getchar();}
while(isdigit(c)){res = (res << 3) + (res << 1) + c - '0'; c = getchar();}
return res * fl;
}
const int maxn = 1050010;
int ans1, ans2, q, op, x, trie[2][maxn * 20], cnt, vis[maxn];
int Max(int A, int B){
if(A < B) return B;
return A;
}
void insert(int num){
int k = 0;
for(int i(20); i >= 0; --i){
int b1 = (num >> i) & 1;
if(!trie[b1][k]) trie[b1][k] = ++cnt;
k = trie[b1][k];
}
}
int queryxor(int num){
int k(0), res(0);
for(int i(20); i >= 0; --i){
int b1 = (num >> i) & 1;
if(trie[!b1][k]){
res += (1 << i);
k = trie[!b1][k];
}
else k = trie[b1][k];
}
return res;
}
int main(){
// freopen("B2.in", "r", stdin);
q = rd();
for(int i(1); i <= q; ++i){
op = rd(), x = rd();
if(op == 1){
insert(x);
if(!vis[x])
for(int i(x); i; i = (i - 1) & x) vis[i] = 1;
continue;
}
if(op == 3){
printf("%d\n", queryxor(x)); continue;
}
ans1 = ans2 = 0;
for(int i(20); i >= 0; --i){
if(x & (1 << i)){//当前为1，&希望为1，| 无所谓
if(vis[ans1 | (1 << i)]) ans1 |= (1 << i);
}
//当前为0，& 无所谓，|希望为1
else if(vis[ans2 | (1 << i)]) ans2 |= (1 << i);
}
printf("%d %d %d\n", queryxor(x), ans1, ans2 | x);
}
return 0;
}
20连测_Day2_染色
20连测_Day3_A
预处理 popcount
我的方法：
for(int i(1);i<len;++i){pct[i]=pct[i-lowbit(i)]+1;}
老师的方法：
for(int x(1);x<=n;++x) popct[x] = popct[x >> 1] + (x & 1);
内存过大，数组访问不连续，不如O(n)跑函数
以下写法在 n=25,m=291 的极限数据情况下，运行时间超过了2000ms。
unsigned pct[35000000];
inline void dfs(unsigned pos,unsigned cnt,unsigned sta){
if(pos==n){++ans[cnt]; return;}
dfs(pos+1,cnt,sta);
dfs(pos+1,cnt+pct[sta&G[pos]],sta|(1<<pos));
}
int main(){
...
for(unsigned i(1);i<(1<<n);++i) pct[i]=pct[i>>1]+(i&1);
dfs(0,0,0);
...
}
而以下写法同样的数据只花费了324ms。
inline int pct(unsigned x){
unsigned res(0);
for(;x;x-=lowbit(x)) res++;
return res;
}
inline void dfs(unsigned pos,unsigned cnt,unsigned sta){
if(pos==n){++ans[cnt]; return;}
dfs(pos+1,cnt,sta);
dfs(pos+1,cnt+pct(sta&G[pos]),sta|(1<<pos));
}
int main(){
dfs(0,0,0);
}
这是因为 pct 数组的大小有3.5e7，内存访问不连续，所以慢到理论上的\(O(1)\)查询还不如写一个函数来 \(O(n)\) 求。
20连测_Day3_B[莫反板题]
\(\sum_{i=l}^{i<=r}[gcd(a_i,x)==1] \\= \sum_{i=l}^{i<=r}\sum_{d|gcd(a_i,x)}\mu(d) \\= \sum_{i=l}^{i<=r}\sum_{d|x,d|d_i}\mu(d) \\= \sum_{d|x}\sum_{i=l}^{i<=r}[d|a_i]*\mu(d)\)
这时候的神仙操作就是先给所有询问按照 r 排序，然后总的均摊 O(n) 处理所有 r 前面的 a[i]。
更神仙的是对于左端点 l ，只需要给 l-1 乘一个 -1 的系数，转化为 r，一并排序，然后在最终输出答案的时候再把 r 得到的答案减去 l 得到的答案即可。
对于 \(d|a_i\) 相当于是我们要找一个数 d 的倍数的出现次数。
那么处理a[i]的操作就是\(O(\sqrt(a))\)算出他是那些数的倍数即可。
\(\mu(x)=1 if (x == 1);\\=(-1)^k if (x 无平方因数且 x=\Pi_{i=1}^{i<=k}p_i)\\0 else\)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int rd(){
int res = 0, fl = 1; char c = getchar();
while(!isdigit(c)){if(c == '-') fl = -1; c = getchar();}
while(isdigit(c)){res = (res << 3) + (res << 1) + c - '0'; c = getchar();}
return res * fl;
}
const int maxn = 100010;
int mu[maxn];
unsigned not_pri[maxn], pri[maxn], top, q, n, m, l, r, x, a[maxn], cnt[maxn], ans[maxn];
unsigned sum[1010][maxn];
map<pair<int, int>, int> Cnt;
int Gcd(int A, int B){
return B ? Gcd(B, A % B) : A;
}
int cal(int x){
int i, ans(0);
for(i=1;i*i<x;++i){
if(!(x%i)){
ans+=mu[i]*cnt[i], ans+=mu[x/i]*cnt[x/i];
}
}
if(i*i==x){
ans+=mu[i]*cnt[i];
}
return ans;
}
void getmu(){
mu[1]=1;
for(int i(2);i<=100000;++i){
if(!not_pri[i]){
pri[++top]=i; mu[i]=-1;
}
for(int j(1);j<=top&&i*pri[j]<=100000;++j){
not_pri[i*pri[j]]=1;
if(i%pri[j]==0){
mu[i*pri[j]]=0;break;
}
mu[i*pri[j]]=-mu[i];
}
}
}
struct Query{
int r,x,id,t;
Query(){}
Query(int R,int X,int Id,int T){
r=R,x=X,id=Id,t=T;
}
bool operator < (Query Q) const {
return this->r < Q.r;
}
}qry[maxn*2];
int main(){
getmu();
n = rd(),m = rd();
for(int i(1); i <= n; ++i) a[i]=rd();
for(int i(1); i <= m; ++i){
l=rd()-1,r=rd(),x=rd();
qry[++q]=Query(l,x,i,-1), qry[++q]=Query(r,x,i,1);
}
sort(qry+1,qry+1+q);
int c1(1);
for(int i(0);i<=n;++i){
int x;
for(x=1;x*x<a[i];++x){
if(!(a[i]%x)) cnt[x]++,cnt[a[i]/x]++;
}
if(x*x==a[i]) cnt[x]++;
while(c1<=q&&qry[c1].r<=i){
ans[qry[c1].id]+=qry[c1].t*cal(qry[c1].x);
c1++;
}
}
for(int i=1;i<=m;++i) printf("%d\n",ans[i]); printf("\n");
return 0;
}
//sqrt(100000)=316 3e7
//pri_100000 = 1e4
//1e5*1e4/64=1.6e7
NOIp_Day6_买
我在NOIp模拟赛中做小学奥数原题爆零了
一次买一个，慢死。
一次买 \(\rm a\) 个直到钱不够 \(\rm a * x\)，有点慢。
买 \(\rm a\) 个得到 \(b\) 元钱，实际花费 \(\rm (a*x-b)\) 元钱，如果 \(a * x - b <= 0\)，我就可以无限买。
\(n/(a*x-b)\) 表示买多少个 \(a\)，但是当我的钱不够买 \(\rm a\) 个但是却能花费 \(\rm a * x - b\) 时是不能买的，所以先买 \((n-a*x)/(a*x-b)\) 个。【1】
可以确定的是
那么现在我还有 \(n=(n-a*x)\mod(a*x-b)+a*x\) 元钱，考虑我肯定至少还能买一开始保底的 \(a\) 个，而且还有剩钱。
设 \(rest=(n-a*x)\mod(a*x-b)\) 在 $$
我能否买 \(2*a\) 个？ \(3*a\) 个呢？ 说不定可以，我买 \(a\) 还能增加 \(\rm b\) 元钱，加上我剩的钱，我还能进行一波【1】操作。
最后剩的钱绝对凑不够 \(a * x\) 就只能单买了。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int rd(){
int res = 0, fl = 1; char c = getchar();
while(!isdigit(c)){if(c == '-') fl = -1; c = getchar();}
while(isdigit(c)){res = (res << 3) + (res << 1) + c - '0'; c = getchar();}
return res * fl;
}
int T;
ll ans, a, b, x, n, money;
int main(){
T=rd();
for(int t(1);t<=T;++t){
ans=0;n=rd(),x=rd(),a=rd(),b=rd();
if(n<x){
printf("0\n"); continue;
}
if(n>=x*a&&a*x<=b){
printf("-1\n"); continue;
}
if(b==0){
ans=n/x;
printf("%lld\n",ans); continue;
}
if(n<a*x){
printf("%lld\n",n/x); continue;
}
ll l=(n-a*x)/(a*x-b);
money=n-l*(a*x-b);
ll l_=money%(a*x);
ll l__=l_/(a*x-b)+1;
money-=l__*(a*x-b);
ans=l*a+l__*a+money/x;
printf("%lld\n", ans);
}
return 0;
}
/*
5
100000000 2 1 1
1000000000 100 2 99
6651238 99 2 186
100000000 100000000 2 100000001
594580363 1 249195783 241474592
*/
NOIp_Day7_C
\(设 f(x)=\sum_{d|x} (\mu(\frac{x}{d}) * d)\)
\(那么 gcd(x, y)=\sum_{d|x,d|y} f(d)\)
\(gcd(x,y)=\sum_{d|x,d|y}(\sum_{g|d}(\mu(\frac{d}{g}) * g))\)
证明:
不会.
枚举 \(\rm j\), 枚举 \(a_j\) 的因子 \(\rm d\), 这样对于每一个 \(\rm i\), 如果 \(a_i\) 有 \(\rm d\) 这个因子就会对答案有贡献.
记录 \(f[d] = \sum_{g|d} \mu(\frac{d}{g}) * g, O(n\sqrt{n})\)
维护 \(sum[d]=\sum_{i \leq j \And d|a[i] \And d|a[j]} i\)
维护 \(squm[d]=\sum_{i \leq j \And d|a[i] \And d|a[j]} i*i\)
用 Cal() 计算\(\sum_{i}( (i,j) 被包含的区间数量)\)
Ans += Cal(j, d) * f[d];
20连测_Day9_B_操作数列
给出一个长度为 \(k\) 的数列，然后给出 \(n\) 个操作,操作分为三种：
- a[i]=b
- a[i]+=b
- a[i]*=b
其中 \(i,b\) 是给定的，每个操作只能用一次，最多使用 \(m\) 个操作，让整个数列的乘积最大。
实际操作
- 覆盖操作：对于每一个 \(a[i]\) 最多进行一次覆盖操作，也就是那个最大的 \(b\)
- 增加操作：增加操作一定是在覆盖操作之后进行的，不然就白覆盖了。优先选择 \(b\) 大的加操作
- 乘操作：乘操作一定放在加操作之后，优先选择 \(b\) 大的乘操作
思考实际上的操作过程，对于每一个 \(a_i\)，一开始可能有一次覆盖操作，也可能没有，这要看覆盖操作自己的本身，接下来进行的是一些 \(b\) 单调不增的加操作，最后是一些 \(b\) 单调不增的乘操作。
连续！连续！前缀！前缀！
由于最终的答案很大，所以没法按照一次操作结束后 \(a\) 的值进行排序，但是按照操作后的数与操作前的数的比值进行排序是完全没问题的。
设 \(Pi=\Pi_{i=1}^{k} a_i\)，考虑进行一次乘操作之后，\(Pi\) 要乘上 \(b\)；
进行一次加操作后，\(Pi\) 变成 \(Pi+b\)，相当于乘上了 \(\frac{Pi+b}{Pi}\)；
我们考虑把覆盖转化为加操作，覆盖 \(b\) 变成加 \(b-a\)。
这样对 \(a_i\) 的三种操作产生的实际效果都转化成为了对 \(Pi\) 的乘法。
乘标记——实际操作的提炼与转化
考虑所有的加操作（包括由覆盖操作转化过来的），按照 \(b\) 递减排序，从前往后扫，维护 \(sum_i\) ，\(sum_i\) 一开始等于 \(a_i\) 那么当前操作的乘标记即为 \(\frac{sum_i+b}{sum_i}\)，然后把 \(b\) 累加到 \(sum_i\) 里面。
原先乘法的乘标记就是 \(b\)。
之所以我们能够记录一个 \(sum_i\) ，都基于操作的单调性和连续性，一旦我们进行了当前操作，意味着差值比当前操作大的那些操作一定会进行。
贪心
排序，选乘标记大于1的前 \(m\) 个。
#include<bits/stdc++.h>
#define Mod 1000000007
using namespace std;
typedef long long ll;
int rd(){
int res = 0, fl = 1; char c = getchar();
while(!isdigit(c)){if(c == '-') fl = -1; c = getchar();}
while(isdigit(c)){res = (res << 3) + (res << 1) + c - '0'; c = getchar();}
return res * fl;
}
const int maxn = 1000010;
struct Add{
double Tmp;
ll del;
int id;
}add[maxn];
struct MUL{
ll Mul;
int id;
}mul[maxn];
int k, n, m, T, I, tot, top, cnt, Tot;
ll a[maxn], cov[maxn], Sum[maxn], ans(1), B;
bool CmpAdd(Add A, Add B){
return A.del>B.del;
}
bool CmpTmp(Add A, Add B){
return A.Tmp>B.Tmp;
}
struct Op{
double Tmp;
int id, tp, pos;
}Ans[maxn];
bool operator < (Op A, Op B){
return A.Tmp < B.Tmp;
}
priority_queue<Op> Q;
int main(){
k=rd(), n=rd(), m=rd();
for(int i(1);i<=k;++i) a[i]=rd();
for(int i(1);i<=n;++i){
T=rd(),I=rd(),B=rd();
if(T==1) cov[I]=max(cov[I],B);
else if(T==2) add[++tot].del=B, add[tot].id=I;
else mul[++top]={B,I};
}
for(int i(1);i<=top;++i) Q.push(Op{mul[i].Mul,mul[i].id,3,i});
for(int i(1);i<=k;++i) if(cov[i]){
add[++tot].del=cov[i]-a[i], add[tot].id=i;
}
sort(add+1,add+1+tot,CmpAdd);
for(int i(1);i<=k;++i) Sum[i]=a[i];
for(int i(1);i<=tot;++i){
add[i].Tmp=1.0*(add[i].del+Sum[add[i].id])/Sum[add[i].id];
Q.push(Op{add[i].Tmp, add[i].id, 2, i});
Sum[add[i].id]+=add[i].del;
}
while(Q.size()){
Op u=Q.top(); Q.pop();
if(u.Tmp <= 1) break;
cnt++;
Ans[++Tot]=u;
if(cnt>=m) break;
}
for(int i(1);i<=Tot;++i){
if(Ans[i].tp==2){
a[Ans[i].id]=(a[Ans[i].id]+add[Ans[i].pos].del)%Mod;
}
}
for(int i(1);i<=Tot;++i){
if(Ans[i].tp==3){
a[Ans[i].id]=a[Ans[i].id]*mul[Ans[i].pos].Mul%Mod;
}
}
for(int i(1);i<=k;++i) ans=ans*a[i]%Mod;
printf("%lld\n", ans);
return 0;
}
