[62] (NOIP 集训) NOIP2024加赛 2

合集 - 赛事(59)

1.Codeforces Round 955 (Div. 2)2024-06-262.AtCoder Beginner Contest 3632024-07-213.AtCoder Regular Contest 182（A B C）2024-08-124.暑假集训CSP提高模拟12024-07-185.暑假集训CSP提高模拟22024-07-196.暑假集训CSP提高模拟72024-07-257.暑假集训CSP提高模拟52024-07-238.暑假集训 加赛12024-07-229.暑假集训CSP提高模拟42024-07-2110.暑假集训CSP提高模拟182024-08-1111.暑假集训CSP提高模拟172024-08-1012.暑假集训CSP提高模拟 162024-08-0813.暑假集训CSP提高模拟 ∫[0,6] (x^2)/6 dx2024-07-3114.暑假集训CSP提高模拟112024-07-2915.暑假集训SCP提高模拟102024-07-2816.暑假集训PVZ提高模拟92024-07-2717.暑假集训CSP提高模拟82024-07-2618.暑集假训SCP提高拟模212024-08-1519.[CL-FOOL] CLOI 愚人赛的部分官方题解与小杂谈2024-04-0220.トヨタ自動車プログラミングコンテスト2024#7（ABC 362）2024-07-1421.寒假集训测试2 题目转存2024-02-2322.HEOI2024 题目转存2024-03-0523.高一小学期22024-07-0824.张江蔡2024-06-2725.高一高考集训总结赛2024-06-1326.高一下二调题目转存2024-04-1527.CSP提高组模拟12024-07-1228.Atcoder Beginner Contest 3672024-08-1829.[R18][中国語翻訳]HDKのABC370赛試（ABC370）2024-09-0830.[30] CSP 加赛 12024-09-1531.[33]（CSP 集训）CSP-S 模拟 42024-09-2532.[34]（CSP 集训）CSP-S 联训模拟 12024-09-2633.[35] (CSP 集训) CSP-S 模拟 52024-09-2734.[36]（CSP 集训）CSP-S 模拟 62024-09-2835.AtCoder Beginner Contest 3732024-09-2936.[37]（CSP 集训）CSP-S 模拟 72024-09-3037.[39] (多校联训) A层冲刺NOIP2024模拟赛012024-10-0338.[40]（CSP 集训）CSP 联训模拟 22024-10-0539.[42] (多校联训) A层冲刺NOIP2024模拟赛032024-10-0740.[41] (CSP 集训) CSP-S 模拟 92024-10-0741.[44] (多校联训) A层冲刺NOIP2024模拟赛042024-10-0942.[45] (多校联训) A层冲刺NOIP2024模拟赛052024-10-1143.[46] (多校联训) A层冲刺NOIP2024模拟赛062024-10-1244.パナソニックグループ プログラミングコンテスト2024（ABC 375）2024-10-1345.[47] (CSP 集训) CSP-S 模拟 112024-10-1446.[49 & 50] (多校联训) A层冲刺NOIP2024模拟赛08 | CSP-S 模拟 122024-10-1847.[51] (多校联训) A层冲刺NOIP2024模拟赛092024-10-1948.Atcoder Beginner Contest 3762024-10-2049.Codeforces Round 980 (Div. 2)2024-10-2050.[54] (多校联训) A层冲刺NOIP2024模拟赛122024-10-2451.[57] (多校联训) A层冲刺NOIP2024模拟赛152024-10-2952.[61] (多校联训) A层冲刺NOIP2024模拟赛182024-11-05

53.[62] (NOIP 集训) NOIP2024加赛 22024-11-06

54.[63] (多校联训) A层冲刺NOIP2024模拟赛192024-11-0755.[68] (炼石计划) NOIP 模拟赛 #202024-11-1456.[68] (NOIP集训) NOIP2024 加赛 52024-11-2057.[72] (多校联训) A层冲刺NOIP2024模拟赛252024-11-2258.[73] (NOIP集训) NOIP2024 加赛 72024-11-2259.[75] (NOIP集训) NOIP2024 加赛 82024-11-27

收起

lhx: 为啥你不会线性筛，这么重要的东西
lhx: 你不筛积性函数吗
我: 我一般做数学题推不到需要上线性筛的地方
lhx: 哦那你确实用不到

A.新的阶乘

找质数 $p$ 在式子中的幂，其实就是带权找 $p$ 在 $[1,n]$ 所有数中的出现次数

发现 $[1,n]$ 中所有数只有形如 $kp$ 的数能够被找出因子 $p$

因此尝试枚举所有 $p$ 的倍数来更新 $p$ 的答案

发现这玩意和埃氏筛天作之合，你枚举倍数的时候顺便就把质数筛了，考虑直接上埃氏筛

因为不会怎么求因子出现个数于是用了复杂度很假的暴力做法

理论 $n\log \log n\log n$，实测 0.3s

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
bool notprime[10000001];
vector<int>ans;
inline int powof(int i,int j){
    int res=0;
    while(j){
        if(j%i==0) j/=i,res++;
        else break;
    }
    return res;
}
signed main(){
    cin>>n;
    notprime[0]=true;
    notprime[1]=true;
    for(int i=2;i<=n;++i){
        if(notprime[i]==false){
            ans.push_back(i);
            int cnt=n-i+1;
            for(int j=2;j*i<=n;++j){
                notprime[i*j]=true;
                cnt+=(powof(i,j)+1)*(n-j*i+1);
            }
            ans.push_back(cnt);
        }
    }
    cout<<"f("<<n<<")=";
    if(n<=1) cout<<n;
    for(int i=0;i<=(int)ans.size()-1;i+=2){
        if(i!=0) cout<<'*';
        if(ans[i+1]==1){
            cout<<ans[i];
        }
        else{
            cout<<ans[i]<<'^'<<ans[i+1];
        }
    }
}

B.博弈树

写爆搜打表找规律发现：所有节点中，Bob 至多只有一个

爆搜

#include<bits/stdc++.h>
using namespace std;
int n,q;
vector<int>e[1001];
int deep[1001],fa[10][1001],w[10][1001];
void dfs(int now,int last){
    deep[now]=deep[last]+1;
    fa[0][now]=last;
    for(int i:e[now]){
        if(i!=last){
            w[0][i]=1;
            dfs(i,now);
        }
    }
}
inline void prework(){
    for(int i=1;i<=9;++i){
        for(int j=1;j<=n;++j){
            fa[i][j]=fa[i-1][fa[i-1][j]];
            w[i][j]=w[i-1][j]+w[i-1][fa[i-1][j]];
        }
    }
}
inline int dis(int x,int y){
    if(deep[x]<deep[y]) swap(x,y);
    int res=0;
    for(int i=9;i>=0;--i){
        if(deep[fa[i][x]]>=deep[y]){
            res+=w[i][x];
            x=fa[i][x];
        }
    }
    if(x==y) return res;
    for(int i=9;i>=0;--i){
        if(fa[i][x]!=fa[i][y]){
            res+=w[i][x]+w[i][y];
            x=fa[i][x];
            y=fa[i][y];
        }
    }
    return res+w[0][x]+w[0][y];
}
//true = win
bool bydfs(int now,int lastdis){
    for(int i=1;i<=n;++i){
        if(i!=now){
            int tmp=dis(i,now);
            if(tmp>lastdis){
                if(bydfs(i,tmp)==false) return true;
            }
        }
    }
    return false;
}
int main(){
    cin>>n>>q;
    for(int i=1;i<=n-1;++i){
        int x,y;cin>>x>>y;
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(1,0);
    prework();
    while(q--){
        int t;cin>>t;
        cout<<(bydfs(t,0)?"Alice":"Bob")<<'\n';
    }
}

而且这个点离树的中心极其近

额外发现当树的重心有两个的时候，没有 Bob

尝试直接特判树的重心假完了

手摸了出错的数据发现，应该是自己树的重心这个思路不对，考虑到 Bob 和 Alice 的博弈过程，这里应该是某种和树上距离有关的 “重心”

于是想出了正确的结论

• 定义重心为使得到所有点的距离的最大值最小的节点
• 如果重心只有一个，Bob 会在此处获胜，否则均为 Alice 获胜

证明：

考虑如果先手在直径的一个端点上，可以通过移动到另一个端点来直接胜出，否则不能移动到直径的端点上，否则后手会移动到另一个端点而直接胜出

考虑删除了原树所有直径的端点的树，如果初始点在这棵树上为直径的某一个端点，那么也一定是先手必胜的，因为先手可以将点移动到直径另一个端点，这样后手就一定会将点移动到原树的直径端点上，并且移动的长度一定小于原树直径，这样先手就可以将点移动到原树的另一个直径端点取得胜利

因此后手胜利，当且仅当先手无论如何都会移动到某层的直径端点上，这样的情况只会在只存在一个点不在某层的直径端点上的图上，并且该点恰好为重心

但是这个东西却是 $n^2$ 的，过不了 ${10}^5$

但是你没必要去枚举所有的点，因为重心一定在树的直径上，而且一定是直径上靠近中点的位置，你直接去判断靠近直径中点那几个点就行了

被 $n=1$ 卡了，$n=1$ 无论如何都是 Bob 赢

#include<bits/stdc++.h>
using namespace std;
int n,q;
vector<int>e[100001];
vector<int>zx;
int size[100001];
int maxsonsize[100001];
int deep[100001],fa[20][100001],w[20][100001];
void dfs(int now,int last){
    deep[now]=deep[last]+1;
    fa[0][now]=last;
    for(int i:e[now]){
        if(i!=last){
            w[0][i]=1;
            dfs(i,now);
        }
    }
}
inline void prework(){
    for(int i=1;i<=19;++i){
        for(int j=1;j<=n;++j){
            fa[i][j]=fa[i-1][fa[i-1][j]];
            w[i][j]=w[i-1][j]+w[i-1][fa[i-1][j]];
        }
    }
}
inline int dis(int x,int y){
    if(deep[x]<deep[y]) swap(x,y);
    int res=0;
    for(int i=19;i>=0;--i){
        if(deep[fa[i][x]]>=deep[y]){
            res+=w[i][x];
            x=fa[i][x];
        }
    }
    if(x==y) return res;
    for(int i=19;i>=0;--i){
        if(fa[i][x]!=fa[i][y]){
            res+=w[i][x]+w[i][y];
            x=fa[i][x];
            y=fa[i][y];
        }
    }
    return res+w[0][x]+w[0][y];
}
int minsize=0x7fffffff;
void dfs2(int i){
    int maxdis=0;
    for(int j=1;j<=n;++j){
        maxdis=max(maxdis,dis(i,j));
    }
    if(maxdis<minsize){
        minsize=maxdis;
        zx={i};
    }
    else if(maxdis==minsize){
        zx.push_back(i);
    }
}
int dis5[100001];
int dis6[100001];
int maxdis5,maxdis5id;
int maxdis6,maxdis6id;
void dfs5(int now,int last){
    for(int i:e[now]){
        if(i!=last){
            dis5[i]=dis5[now]+1;
            if(dis5[i]>maxdis5){
                maxdis5=dis5[i];
                maxdis5id=i;
            }
            dfs5(i,now);
        }
    }
}
void dfs6(int now,int last){
    for(int i:e[now]){
        if(i!=last){
            dis6[i]=dis6[now]+1;
            if(dis6[i]>maxdis6){
                maxdis6=dis6[i];
                maxdis6id=i;
            }
            dfs6(i,now);
        }
    }
}
vector<int>zj;
bool dfs7(int now,int last,int tar){
    if(now==tar){
        zj.push_back(now);
        return true;
    }
    for(int i:e[now]){
        if(i!=last){
            if(dfs7(i,now,tar)){
                zj.push_back(now);
                return true;
            }
        }
    }
    return false;
}
void dfs8(){
    int tmp=(int)zj.size()/2;
    int tmp2=tmp-1;
    if(tmp>=0) for(int i:e[zj[tmp]]) dfs2(i);
    if(tmp2>=0) for(int i:e[zj[tmp2]]) dfs2(i);
}
int main(){
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);
    cin>>n>>q;
    if(n==1){
        while(q--){
            cout<<"Bob\n";
        }
        return 0;
    }
    for(int i=1;i<=n-1;++i){
        int x,y;
        cin>>x>>y;
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(1,0);
    prework();
    dfs5(1,0);
    dfs6(maxdis5id,0);
    dfs7(maxdis5id,0,maxdis6id);
    dfs8();
    while(q--){
        int t;cin>>t;
        if(zx.size()!=1ull) cout<<"Alice\n";
        else if(zx[0]!=t) cout<<"Alice\n";
        else cout<<"Bob\n";
    }
}

C.划分

先说 corner case

• $n=k$

显然了，只有唯一的划分方式

• 字符串最前面有超过 $k$ 位全是 $0$

这个时候直接在前面划就行了，无论你怎么拆后面带 $1$ 的字符串都只会让答案更小

设前面有 $p$ 个 $0$，划分成 $k$ 段，需要插 $k-1$ 块板，注意最后一个 $0$ 后面也是能插的，答案即为 $\sum _{i=k-1}^p{C}_p^i$，预处理阶乘直接算即可

注意这个 case 有一个全 $0$ 的特殊情况，在第三个 hack

• 通解

上面两个 corner case 都要判掉再做通解

最优解一定形如选出 $k-1$ 个单个的区间，剩下一个连续的大区间单独分一段（区间越长高位贡献越大）

这样剩余的情况就只有 $k$ 种了，可以暴力判断哪一种情况更优

因为 $1$ 的个数一样，实际上谁的高位 $1$ 个数更多，谁的答案就更大

发现有人不理解这句话：实际上，因为你 $1$ 的个数是固定的，而每个 $1$ 都会给答案带来一个 $2^k$ 的贡献（$k$ 是 $1$ 所在的位置），因此你肯定是要最大化每个 $k$ 的值，也就是高位 $1$ 个数尽可能多/高，而我们说最低位和单独的 $1$ 没用，是因为无论怎么分，每个 $1$ 总是会有至少 $2^0$ 的贡献，相当于最低位和单独的 $1$ 没做出任何额外贡献，在这一点上二者是等价的

因此只比较那个长区间，直接暴力比较是 $O(len)$ 的，为了规避暴力比较，可以用二分+哈希求出需要比较的两个区间的最长公共前缀，然后直接比较后一位，可以做到 $O(\log len)$

这里注意最长公共前缀等于原串的情况，有可能会越界

还是那句话，谁的高位 $1$ 个数更多，谁的答案就更大，因此我们判方案数的时候也是同理，因为最低位的 $1$ 和单独的 $1$ 贡献是一样的，因此两个串答案相同，当且仅当最长的区间去除最低位后相等，依旧用哈希判断

注意卡模数的问题

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int p=998244353;
const int P1=1e9+3,P2=1e7+0721;
int n,k;
string x;
int power(int a,int t){
    int base=a,ans=1;
    while(t){
        if(t&1){
            ans=ans*base%p;
        }
        base=base*base%p;
        t>>=1;
    }
    return ans;
}
int fact[2000001];
int C(int n,int m){
    return fact[n]*power(fact[m]*fact[n-m]%p,p-2)%p;
}
int cal(int l,int r){
    int res=0;
    for(int i=l;i<=r;++i){
        res=(res*2+x[i]-'0')%p;
    }
    return res;
}
const unsigned long long num=233,num2=2333;
unsigned long long h[2000001],basenum[2000001];
unsigned long long geth(int l,int r){
    if(l>r) return 0;
    return (h[r]-h[l-1]*basenum[r-l+1]%P1+P1)%P1;
}
unsigned long long h2[2000001],basenum2[2000001];
unsigned long long geth2(int l,int r){
    if(l>r) return 0;
    return (h2[r]-h2[l-1]*basenum2[r-l+1]%P2+P2)%P2;
}
bool great(int now,int ori){
    int l=0,r=n-k+1,ans=0;
    while(l<=r){
        int mid=(l+r)/2;
        if(geth(now,now+mid-1)==geth(ori,ori+mid-1) and geth2(now,now+mid-1)==geth2(ori,ori+mid-1)){
            l=mid+1;
            ans=mid;
        }
        else r=mid-1;
    }
    if(ans==n-k+1) return false;
    return x[now+ans]>x[ori+ans];
}
inline int cal2(int l,int r){
    int res=0;
    for(int i=1;i<l;++i){
        res=(res+x[i]-'0')%p;
    }
    int res2=0;
    for(int i=l;i<=r;++i){
        res2=(res2*2+x[i]-'0')%p;
    }
    res=(res+res2)%p;
    for(int i=r+1;i<=n;++i){
        res=(res+x[i]-'0')%p;
    }
    return res;
}
signed main(){
    cin>>n>>k>>x;x=" "+x;
    if(n==k){
        int res=0;
        for(int i=1;i<=n;++i){
            res=(res+x[i]-'0')%p;
        }
        cout<<res<<" "<<1;
        return 0;
    }
    fact[0]=1;
    basenum[0]=1;
    basenum2[0]=1;
    for(int i=1;i<=n;++i){
        fact[i]=fact[i-1]*i%p;
        h[i]=(h[i-1]*num+x[i])%P1;
        basenum[i]=basenum[i-1]*num%P1;
        h2[i]=(h2[i-1]*num2+x[i])%P2;
        basenum2[i]=basenum2[i-1]*num2%P2;
    }
    int first1=n;
    for(int i=1;i<=n;++i){
        if(x[i]=='1'){
            first1=i;
            break;
        }
    }
    if(first1>=k){
        cout<<cal(1,n)<<' ';
        int res=0;
        for(int i=k-1;i<=first1-1;++i){
            res=(res+C(first1-1,i))%p;
        }
        cout<<res;
        return 0;
    }
    int maxid=0;
    for(int i=1;i<=k;++i){
        if(maxid==0) maxid=i;
        else{
            if(great(i,maxid)){
                maxid=i;
            }
        }
    }
    cout<<cal2(maxid,maxid+n-k)<<" ";
    int res=0;
    for(int i=1;i<=k;++i){
        if(geth(i,i+n-k-1)==geth(maxid,maxid+n-k-1) and geth2(i,i+n-k-1)==geth2(maxid,maxid+n-k-1)) res++;
    }
    cout<<res;
}

D.灯笼

---

这是什么