Educational Codeforces Round 176 (Rated for Div. 2)

最新推荐文章于 2026-06-29 13:05:28 发布
原创 最新推荐文章于 2026-06-29 13:05:28 发布 · 981 阅读 · 29 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
codeforces

当前文章被收录于：

codeforces
6 篇文章 0 人学习
订阅专栏 查看详情

文章目录

前言

题目链接CF2075

A - To Zero

签到

#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int,int> PII;
const int N=5e5+10,M=2e5+10;
// const int INF=1e18;
// const int mod=998244353;
// const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve(){ 
    int n,k;
    cin>>n>>k;
    if(n%2==0){
        k--;
        cout<<(n+k-1)/k<<"\n";
        return;
    }
    if(n<=k){
        cout<<1<<"\n";
        return;
    }
    n-=k;
    k--;
    cout<<(n+k-1)/k+1<<"\n";
}   
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    cin>>T;
    while(T--)solve();
    return 0;
}

B - Array Recoloring

在这里插入图片描述

  • 选择top k+1个元素即可
  • 特判k=1，此时只能中间选一个，然后选两边中的一个；或者两边全选
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int,int> PII;
const int N=5e5+10,M=2e5+10;
// const int INF=1e18;
// const int mod=998244353;
// const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve(){ 
    int n,k;
    cin>>n>>k;
    vector<int> a(n+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    if(k==1){
        if(n==2)cout<<a[1]+a[2]<<"\n";
        else{
            int mx=0;
            for(int i=2;i<n;i++)mx=max(mx,a[i]);
            cout<<max(mx+max(a[1],a[n]),a[1]+a[n])<<"\n";
        }
        return;
    }
    sort(a.begin()+1,a.end(),greater<int>());
    int ans=0;
    for(int i=1;i<=k+1;i++)ans+=a[i];
    cout<<ans<<"\n";
}   
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    cin>>T;
    while(T--)solve();
    return 0;
}

C - Two Colors

在这里插入图片描述

  • 假设两种颜色的数量为 x , y x,y x,y，那么这两个的方案为 min ⁡ ( n − 1 , y ) − max ⁡ ( 1 , n − x ) \min(n-1,y)-\max(1,n-x) min(n−1,y)−max(1,n−x),可以用树状数组做维护后面max的总和和数量，就可以转移
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int,int> PII;
const int N=5e5+10,M=2e5+10;
// const int INF=1e18;
// const int mod=998244353;
// const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
template<typename T,typename F>
struct Fenwick{
    int n;
    vector<T> c;
    T identity;
    F op;
    Fenwick(){}
    Fenwick(int n_,T identity_=0){
        init(n,identity);
    }
    void init(int n_,T identity_=0){
        n=n_;
        c.assign(n,identity);
        identity=identity_;
    }
    void add(int x,T v,int rev=0){
        if(rev)x=n-x+1;
        for(;x<=n;x+=x&-x)c[x]=op(c[x],v);
    }
    T query(int x,int rev=0){
        if(rev)x=n-x+1;
        T res=identity;
        for(;x;x&=x-1)res=op(res,c[x]);
        return res;
    }
};
Fenwick<int,decltype([](const int &a,const int &b){return a+b;})> c,s;
void solve(){ 
    int n,m;
    cin>>n>>m;
    vector<int> a(m);
    for(auto &i:a)cin>>i;
    int mx=*max_element(a.begin(),a.end());
    c.init(mx+1);
    s.init(mx+1);
    int ans=0;
    for(int i=0;i<m;i++){
        int x=min(a[i],n-1);
        // cout<<c.query(x)<<" "<<s.query(x)<<"\n";
        ans+=(c.query(x)*(x+1)-s.query(x))*2;
        int y=max(1ll,n-a[i]);
        c.add(y,1);
        s.add(y,y);
    }
    cout<<ans<<"\n";
}   
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    cin>>T;
    while(T--)solve();
    return 0;
}

D - Equalization

在这里插入图片描述

  • 相当于 x x x和 y y y右移若干位相等，且每个右移的次数只能用一次
  • 每个只能选一次，相当于是个01二维背包问题，先预处理出数组 d p i , j dp_{i,j} dpi,j​表示第一个数右移 x x x位第二个数右移 j j j位的最小代价(这里滚动滚掉第一维了)
  • 计算两个数二进制的公共前缀，然后算出 x x x需要右移 a a a位， y y y需要右移 b b b位，那么答案就是 d p a , b dp_{a,b} dpa,b​？
  • 这个是错的，因为如果 a = b = 2 a=b=2 a=b=2那么 d p 2 , 2 dp_{2,2} dp2,2​这个状态不存在，因此答案应该为 d p a + i , b + i dp_{a+i,b+i} dpa+i,b+i​？
  • 这个还是错的，hack:2 3,答案应该为12，但是 d p 3 , 3 = 14 dp_{3,3}=14 dp3,3​=14，如果我们目标是让两个数都为0，那么不必在意同时加 i i i，两维数字可以随便选
  • 上面全部情况取最小即可
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int,int> PII;
const int N=5e5+10,M=2e5+10;
const int INF=LLONG_MAX;
// const int mod=998244353;
// const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<vector<__int128>> dp(63,vector<__int128>(63,INF));
void init(){
    dp[0][0]=0;
    for(int i=1;i<=62;i++){
        vector<vector<__int128>> ndp(63,vector<__int128>(63,INF));
        for(int j=62;j>=0;j--){
            for(int k=62;k>=0;k--){
                ndp[j][k]=min(ndp[j][k],dp[j][k]);
                if(j-i>=0&&dp[j-i][k]!=INF){
                    ndp[j][k]=min(ndp[j][k],dp[j-i][k]+(1ll<<i));
                }
                if(k-i>=0&&dp[j][k-i]!=INF){
                    ndp[j][k]=min(ndp[j][k],dp[j][k-i]+(1ll<<i));
                }
            }
        }
        dp=ndp;
    }
}
void solve(){ 
    int n,m;
    cin>>n>>m;
    if(n==m){
        cout<<"0\n";
        return;
    }
    vector<int> bn,bm;
    while(n)bn.push_back(n%2),n/=2;
    while(m)bm.push_back(m%2),m/=2;
    int i=bn.size()-1,j=bm.size()-1;
    int mxn,mxm;
    if(bn.size()&&bm.size()){
        while(i>=0&&j>=0){
            if(bn[i]!=bm[j])break;
            i--,j--;
        }
        mxn=i+1,mxm=j+1;
    }
    else if(bn.size()){
        mxn=bn.size();
        mxm=0;
    }
    else{
        mxn=0;
        mxm=bm.size();
    }
    // for(int i=0;i<=60;i++){
    //     for(int j=0;j<=60;j++)cout<<format("{} {} {}\n",i,j,dp[i][j]);
    // }
    // cout<<mxn<<" "<<mxm<<"\n";
    __int128 ans=INF;
    for(int i=0;i<=62;i++){
        if(mxn+i<=62&&mxm+i<=62)ans=min(ans,dp[mxn+i][mxm+i]);
        for(int j=0;j<=62;j++){
            if(i>=bn.size()&&j>=bm.size())ans=min(ans,dp[i][j]);
        }
    }
    cout<<format("{}\n",ans);
}   
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    init();
    cin>>T;
    while(T--)solve();
    return 0;
}

E - XOR Matrix

在这里插入图片描述

  • 显然,a、b两个数组都不应该存在大于2个不同的数，否则异或出来不同的数必定大于2
  • 考虑两边数组都选一个，那么答案显然为 ( A + 1 ) ( B + 1 ) (A+1)(B+1) (A+1)(B+1)
  • 如果a有1个，贡献为 A + 1 A+1 A+1,b有2个，那么从 B + 1 B+1 B+1个选2个为 ( B + 1 2 ) \binom{B+1}{2} (2B+1​)，然后每个位置可以任意选两个中的一个，除去全0的状态和全1的状态，有 2 m − 2 2^m-2 2m−2,因此方案为 ( A + 1 ) ( B + 1 2 ) ( 2 m − 2 ) (A+1)\binom{B+1}{2}(2^m-2) (A+1)(2B+1​)(2m−2)
  • 同理如果a有2个，b有1个，答案为 ( B + 1 ) ( A + 1 2 ) ( 2 n − 2 ) (B+1)\binom{A+1}{2}(2^n-2) (B+1)(2A+1​)(2n−2)
  • 最麻烦的是两边数组均2个，此时 a 1 ⊕ b 1 = a 2 ⊕ b 2 a_1 \oplus b_1=a_2 \oplus b_2 a1​⊕b1​=a2​⊕b2​（其他情况如 a 1 ⊕ b 1 = a 1 ⊕ b 2 a_1 \oplus b_1=a_1 \oplus b_2 a1​⊕b1​=a1​⊕b2​不存在，因为此时 b 1 = b 2 b_1=b_2 b1​=b2​了，此时不满足假设条件了，另外一种同理）
  • 两边同时异或上 a 2 ⊕ b 1 a_2 \oplus b_1 a2​⊕b1​，此时设 a 1 ⊕ a 2 = b 1 ⊕ b 2 = x a_1 \oplus a_2=b_1 \oplus b_2=x a1​⊕a2​=b1​⊕b2​=x，假设 0 ≤ a 1 ⊕ x < a 1 ≤ A , 0 ≤ b 1 ⊕ x < b 2 ≤ B 0 \leq a_1 \oplus x \lt a_1 \leq A,0 \leq b_1 \oplus x \lt b_2 \leq B 0≤a1​⊕x<a1​≤A,0≤b1​⊕x<b2​≤B
  • 因为有限制可以使用数位dp解决，设 d p p o s , a , b , c dp_{pos,a,b,c} dppos,a,b,c​表示在低 p o s pos pos位， a = 1 a=1 a=1表示比pos高的位等于A，否则小于A，同理 b b b表示B的， c = 1 c=1 c=1表示此时x=0，否则大于0
  • 使用记忆化搜索
  • 枚举当前位 a 1 a_1 a1​和 b 1 b_1 b1​选什么，和普通数位dp写法一样
  • 特别注意 x x x，如果当前 c = 1 c=1 c=1且a和b有限制，那么此时 x x x位只能选0，选1的话就不满组假设条件了。如果c没了限制，说明前面已经判定了 a 1 ⊕ x < a 1 a_1 \oplus x \lt a_1 a1​⊕x<a1​，当前位已经不是决定位，可以任选0，1
  • 没做过几个数的数位dp，实际上三个limit标志只要有一个没有限制了，就可以直接返回已计算的值，这样只有a=1,b=1,c=1这条线不用记搜，而这条线只会走一次，因此复杂度是对的
  • 复杂度 O ( log ⁡ max ⁡ ( A , B ) ⋅ 2 4 ) O(\log \max(A,B) \cdot 2^4) O(logmax(A,B)⋅24)
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int,int> PII;
const int N=3e5+10,M=2e5+10;
// const int INF=1e18;
const int mod=998244353;
// const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int dp[30][2][2][2],n,m,A,B;
int dfs(int pos,int a,int b,int c){
    if(!pos){
        return dp[pos][a][b][c]=c?0:1;
    }
    if((!a||!b||!c)&&~dp[pos][a][b][c])return dp[pos][a][b][c];
    int upa=a?((A>>pos-1)&1):1;
    int upb=b?((B>>pos-1)&1):1;
    int res=0;
    for(int i=0;i<=upa;i++){
        for(int j=0;j<=upb;j++){
            int na=a&&i==upa;
            int nb=b&&j==upb;
            int upc=c&&(i==0||j==0)?0:1;
            for(int k=0;k<=upc;k++){
                res+=dfs(pos-1,na,nb,c&&!k);
                res%=mod;
            }
        }
    }    
    if(!a||!b||!c)dp[pos][a][b][c]=res;
    return res;
}
int qpow(int a,int b){
    int ans=1;
    for(;b;b>>=1){
        if(b&1)ans=ans*a%mod;
        a=a*a%mod;
    }
    return ans;
}
void solve(){ 
    memset(dp,-1,sizeof dp);
    cin>>n>>m>>A>>B;
    //11
    int res=(A+1)*(B+1)%mod;
    //12
    res+=(B+1)*B/2%mod*(A+1)%mod*(qpow(2,m)+mod-2)%mod;
    res%=mod;
    //21
    res+=(A+1)*A/2%mod*(B+1)%mod*(qpow(2,n)+mod-2)%mod;
    res%=mod;
    //22
    res+=(qpow(2,m)+mod-2)%mod*(qpow(2,n)+mod-2)%mod*dfs(30,1,1,1)%mod;
    res%=mod;
    cout<<res<<"\n";
}   
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    cin>>T;
    while(T--)solve();
    return 0;
}
标签
#算法 #数据结构
D. Equalization【Educational Codeforces Round 176 (Rated for Div. 2)】
csdn可能自动偷偷把博客设为vip可见，可以联系我改回去
03-20 791
Educational Codeforces Round 176 (Rated for Div. 2) D. Equalization 状态压缩（bitmasks）暴力枚举（brute force）动态规划（dp）图论（graphs）贪心（greedy）数学（math）
Educational Codeforces Round 176 (Rated for Div. 2) ABCD
fwdzh的博客
03-18 890
2025-03-17赛时只通过了 ABC ， D看数据才补出来。。。写题解的水平似乎过于低下了一点，不过一般是为了给自己看的。。。但是也希望分享出来看能不能起到一点帮助或者得到大家的指点。虽然写东西的水平一直很低，但是写史花的时间也不少的。。。
Educational Codeforces Round 176 (Rated for Div. 2 补题
2303_80688889的博客
03-22 675
思路：分k是否等于1来分类讨论，如果k不等于1，通过模拟可以发现，就是取最大的k + 1个数，如果k等于1，那就取2个元素，而且第二个元素要么是第一个元素，要么是最后一个元素，遍历一遍即可。)， 前者是固定的，后者我们用一个后缀和求即可，但是我们要注意如果 y == n 或者 x == n，那我们还要减掉这种情况，所以我们再开个cnt数组记录p位置后面有多少个元素 == n。思路：贪心，开始时分n为奇偶分类讨论，每次减能减的最大值即可。
Educational Codeforces Round 176 (Rated for Div. 2)(A-D)
Vcoistnt的博客
03-18 541
Educational Codeforces Round 176 (Rated for Div. 2)补题
Educational Codeforces Round 176 (Rated for Div. 2)(A~D)
2301_77680189的博客
03-18 551
补题。
我的来时路-算法竞赛-Educational Codeforces Round 176 (Rated for Div. 2)（A-D）
qq_62131379的博客
03-18 602
Educational Codeforces Round 176 (Rated for Div. 2)（A-D）题解
Educational Codeforces Round 176 (Rated for Div. 2)(c,d)
2401_87655214的博客
11-09 380
有一个长度为n的木板，和m种颜色，第i种颜色最多能给木板涂a[i]个长度，木板最多只能涂2种颜色，并且同种颜色必须连续（任意相同颜色之间不能有其他颜色），问有多少种涂色方案(n,m<2e5)找到大于等与i的最小下标x，同理找到n-i的最小下标y。1.当$i==(n-i)$时 是对称的答案为:len2*(len2-1)/2;意味 x,y要删(5,1),(6,2),(7,2),(i,j)i>7,j>2;=(n-i)$时，为len2*(len2-1);一种颜色能分成的木块长度i，n-i一共2块。
C. Two Colors-Educational Codeforces Round 176 (Rated for Div. 2)
m0_73817832的博客
03-29 972
（3）假设第一部分要达到的木板颜色数量为i，则第二部分为n-i。第一部分的的数量为数组a中>=i的种类数量，第二部分为数组a中>=n-i的种类数量。（4）然而，题目要求必须是两种不同的颜色，上述我们思路中包含了前后两部分相同的情况，因此需要减去。的最小值的地址，而前面（a+m）则数组最后一个元素再向后一个元素的地址，相减的话就能得到大于等于i的元素数量。我们减去满足这种情况的所有数量就能得到这种i下的所有排列数量。来给栅栏的n个木板染色，且颜色相同的木板是。，返回的是指针，即返回的是大于等于。
B. Array Recoloring-Educational Codeforces Round 176 (Rated for Div. 2)
m0_73817832的博客
03-29 760
这种情况是最后一个染色点要么是最左边的，要么是最右边的，另外一个最大值（及刚开始就选的最值）则是最左边的右边的n-1个点中的最大值，要么就是最后边的点的左边的n-1个点中的最大值。:这种情况是无论如何都能够使得最先染的k个点和最后一个点是最大的k+1个点，因此我们从进行排序，直接累加得到最大的k+1个数的和。（3）我们需要遵守染色的规律并且得到最先染色的前面k个点的值和最后染色点的值的总和。（2）将数组中所有的数看作点，所有的点都是红色的。=>因此需要去分析什么情况下值是最优的（根据染色的规律）。
Educational Codeforces Round 173 (Rated for Div. 2)题解
2301_80475191的博客
12-27 932
思路：思考一下，会发现能不超过每消耗一个4会产生一个2，因此我们有不超过4^x次方的硬币，最多只会变为2^(x-1)的硬币直接敲代码即可思路：通过分析后，会发现，数的各位数总和为为n!*d，我们可以发现，其实那个阶乘最大取到9就可以了，所以我们算出来n!*d，然后能够取模3等于0就说明3是可以的，取模9等于0就说明9也是可以的，只有d为5的时候才能包含5我们来证明一下7的思路。
Educational Codeforces Round 173 (Rated for Div. 2)
MenghuanL的博客
12-26 976
总结：翻译插件用不了了，B题题意一直没看懂，C题出思路了好久才写出来，评价为太久没打了。
Educational Codeforces Round 173 (Rated for Div. 2) A~D
2302_80423900的博客
12-26 1172
对于每个测试用例，打印一个整数 — 执行任意次数操作后可以得到的最大硬币数量。每个和应该只打印一次，即使它是由多个子数组实现的。— 问题的答案，如果不存在这样的对，则输出“-1 -1”。，当数字的各个位上数字相加是3的倍数时，该数能被3整除，如果不存在这样的对，则输出“-1 -1”。对于每个测试用例，按升序输出除以板上写的数字的奇数位。每个和应该只打印一次，即使它是由多个子数组产生的。子数组的所有可能和，包括空子数组，其和定义为。先算出A，B的取值区间，从小值遍历A的范围。
Educational Codeforces Round 57 (Rated for Div. 2)
Panda!!!!!!
02-21 141
https://codeforces.com/contest/1096/problem/B 题解： 比如aacdeee 如果我们想保留左边的a 话 那么需要删除的是aa后面的所有，以及一个a， 连续的a 的长度为2 可删除的为 cdeee acdeee 两种 如果想保留右边e的话 那么要删除的是右边aacd 然后 和两个e 一共三种删除方法。 所以左右不等于的时候 删除方法就很明显了 ...
OpenCV 核心算法大全、解决问题 + 落地应用完整详解
雪的季节
06-29 199
整体分为 7 大模块：基础图像操作、滤波平滑、边缘 / 特征检测、轮廓与形状分析、特征匹配与目标识别、相机标定三维视觉、视频与机器学习，每个模块包含核心算法、解决痛点、实际工程场景。
基于传输熵理论的通信网络拓扑结构推理算法matlab仿真
MATLAB,verilog,python,opencv,tensorflow,caffe,C,C++
06-27 311
本文提出了一种基于传输熵的非协作通信网络拓扑推理算法。在无法获取先验信息的情况下，该算法通过分析节点通信时序数据，计算传输熵量化节点间的有向信息流，结合置换检验和多元条件传输熵方法，有效剔除随机噪声和间接链路干扰，最终构建准确的有向加权网络拓扑。算法支持4-26个节点的网络规模，采用MATLAB实现，包含数据预处理、状态重构、传输熵计算、统计检验等核心模块，可精确还原非线性、时滞性通信网络的拓扑结构。完整程序工程可通过指定方式获取。
【数据结构】排序算法（二）：交换排序——从冒泡到快排的分治进化
weixin_61091020的博客
06-28 6637
交换排序——冒泡排序，快速排序
[LC优选算法#12] 位运算 | 两整数之和 | 只出现一次的数字 II | 消失的两个数字
最新发布
C++开发
06-29 281
本文介绍了三道使用位运算解决的算法题： 两整数之和：通过异或和与运算模拟加法，循环处理进位直至无进位。 只出现一次的数字II：统计每位出现次数后模3，定位唯一数字的各个比特位。 消失的两个数字：结合异或特性分组处理，将问题转化为找两个出现一次的数字。 这些解法均利用位运算高效实现，时间复杂度为O(1)或O(N)，空间复杂度优化至O(1)，展示了位运算在特定场景下的独特优势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值