Codeforces Round 903 (Div. 3) (A~F)题解

最新推荐文章于 2024-08-20 10:48:49 发布
最新推荐文章于 2024-08-20 10:48:49 发布
阅读量246 收藏
点赞数
分类专栏： codeforces 文章标签： 算法 c++ 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71555672/article/details/133824085
版权

目录

A. Don't Try to Count

B. Three Threadlets

C. Perfect Square

D. Divide and Equalize

E. Block Sequence

F. Minimum Maximum Distance

A. Don't Try to Count

Solution:根据题意模拟。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
bool check(string x,string y){
   int len=y.size();
   for(int i=0;i+len-1<x.size();i++){
         if(x.substr(i,len)==y) return 1;
   }
   return 0;
}
void solve()
{
    int n,m;cin>>n>>m;
    string s,t;cin>>s>>t;
    int cnt=0;
    for(int i=0;i<7;i++){
         if(check(s,t)){
             cout<<cnt<<'\n';
             return;
         }else{
             cnt++;
             s+=s;
         }
    }
    cout<<-1<<'\n';
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

B. Three Threadlets

Solution：只能分成3，4，5，6份，最优的选择是最小的不会再被分，然后看能否全分成最小值能不能分成六份以内即可。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
void solve()
{
   LL a ,b,c;cin>>a>>b>>c;
   map<LL,LL>mp;
   LL s=a+b+c;
   LL x=min({a,b,c});
   if(s%3!=0&s%4!=0&&s%5!=0&&s%6!=0){
         cout<<"No"<<'\n';
         return;
   }
   if(!(a%x==0&&b%x==0&&c%x==0)){
           cout<<"No"<<"\n";
           return;
   }
   int cnt=a/x+b/x+c/x-3;
   if(cnt<=3){
       cout<<"Yes"<<'\n';
   }else cout<<"No"<<"\n";
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

C. Perfect Square

Solution：根据题意模拟，记录每个位置旋转四次的最大字母值即可。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
void solve()
{
   int n;cin>>n;
   char mp[n][n];
   for(int i=0;i<n;i++){
      for(int j=0;j<n;j++){
           cin>>mp[i][j];
      }
   }
   LL sum=0;
   map<char,int>mp1;
   for(int i=0;i<n/2;i++){
       for(int j=i;j<n-i-1;j++){
        char mx=mp[i][j];map<char,int>mp1;
        mx=max({mp[i][j],mp[n-1-j][i],mp[n-1-i][n-1-j],mp[j][n-1-i]});
        //cout<<mp[i][j]<<mp[j][n-1-i]<<mp[n-1-i][n-1-j]<<mp[n-1-j][i]<<"\n";
        mp1[mp[i][j]]++;
        mp1[mp[n-1-j][i]]++;
        mp1[mp[n-1-i][n-1-j]]++;
        mp1[mp[j][n-1-i]]++;
        int cnt=0;
        //cout<<mx<<'\n';
        for(char k='a';k<='z';k++){
           if(mp1[k]&&k!=mx){
              //cout<<k<<'\n';
              sum+=(mx-k)*mp1[k];
              cnt+=(mx-k)*mp1[k];
           }
        }
        //cout<<cnt<<'\n';
      }
   }
  cout<<sum<<'\n';
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

D. Divide and Equalize

Solution：因为每个数的质因数分解具有唯一性，因此把数组每个数质因数分解记录出现次数即可。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
void solve()
{
    int n;cin>>n;
    vector<int>ans(n);
    map<int,int>mp;
    int mx=-inf,mx1=-inf;
    set<int>s;
    for(int i=0;i<n;i++) {
        cin>>ans[i];
        int x=ans[i];
        mx1=max(mx1,ans[i]);
        for(int i=2;i<=x/i;i++){
        if(x%i==0){
            int cnt=0;
            while(x%i==0){
                cnt++;
                x/=i;
            }
           mp[i]+=cnt;
           s.insert(i);
           mx=max(mx,i);
        }
    }
    if(x>1) mp[x]++,s.insert(x);
    }
    for(auto t:s){
         if(mp[t]%n!=0){
              cout<<"No"<<'\n';
              return;
         }
    }
    cout<<"Yes"<<'\n';
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

E. Block Sequence

Solution：经典dp，每一位删除或者不删除，dp[i]代表以i为开头的最小删除次数，如果删除的话那么dp[i]=dp[i+1]+1，如果ans[i]<n-i，dp[i]=min(dp[i],dp[i+ans[i]+1])，最终答案为dp[0]。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
void solve()
{
   int n;cin>>n;
   vector<int>ans(n),dp(n+1,n);
   for(int i=0;i<n;i++) cin>>ans[i];
    dp[n]=0;
   for(int i=n-1;i>=0;i--){
        dp[i]=dp[i+1]+1;
        if(ans[i]<n-i){
            dp[i]=min(dp[i],dp[i+ans[i]+1]);
        }
   }
   cout<<dp[0]<<'\n';
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

F. Minimum Maximum Distance

Solution:题意为给定一颗树，定义f[i]为点i到其它被标记点的最大值，求出minf[i](1<=i<=n)。因为一定存在最远的被标记的两个点，因此最小值一定是最远的两个点距离除2并向上取整。因此两次bfs即可。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
using namespace std;
typedef long long  LL;
typedef unsigned long long uLL;
typedef pair<LL,LL> PII;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
template <int T>
struct ModInt {
    const static int MD = T;
    int x;
    ModInt(LL x = 0)
        : x(x % MD) {}
    int get() { return x; }
    ModInt operator+(const ModInt& that) const {
        int x0 = x + that.x;
        return ModInt(x0 < MD ? x0 : x0 - MD);
    }
    ModInt operator-(const ModInt& that) const {
        int x0 = x - that.x;
        return ModInt(x0 < MD ? x0 + MD : x0);
    }
    ModInt operator*(const ModInt& that) const {
        return ModInt((long long)x * that.x % MD);
    }
    ModInt operator/(const ModInt& that) const {
        return *this * that.inverse();
    }
    void operator+=(const ModInt& that) {
        x += that.x;
        if (x >= MD)
            x -= MD;
    }
    void operator-=(const ModInt& that) {
        x -= that.x;
        if (x < 0)
            x += MD;
    }
    void operator*=(const ModInt& that) { x = (long long)x * that.x % MD; }
    void operator/=(const ModInt& that) { *this = *this / that; }
    ModInt inverse() const {
        int a = x, b = MD, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        if (u < 0)
            u += MD;
        return u;
    }
    friend ostream& operator<<(ostream& os, ModInt x) {
        os << x.get();
        return os;
    }
};//全局变量记得清零！
const int mod=998244353;
typedef ModInt<mod> mint;
LL gcd(LL a, LL b)
{
   return b ? gcd(b, a % b) : a;
}
void solve()
{
   int n,k;cin>>n>>k;
   vector<bool>mk(n+1);
   int temp;
   for(int i=0;i<k;i++) {
      cin>>temp;
      mk[temp]=1;
   }
    int a,b;
   vector<int>v[n+1];
   for(int i=0;i<n-1;i++){
        cin>>a>>b;
        v[a].push_back(b),v[b].push_back(a);
   }
   queue<int>q;
   vector<bool>vis(n+1);
   q.push(1);int res=1;
   while(!q.empty()){
     auto t=q.front();
     q.pop();
     vis[t]=1;
     for(auto x:v[t]){
         if(!vis[x]){
            vis[x]=1;
             q.push(x);
             if(mk[x]) res=x;
         }
     }
   }
   vis=vector<bool>(n+1);
q.push(res);vector<int>dis(n+1);
vis[res]=1;int ans=0;
while(!q.empty()){
     auto t=q.front();
     q.pop();
     vis[t]=1;
     for(auto x:v[t]){
         if(!vis[x]){
            vis[x]=1;
             q.push(x);
             dis[x]=dis[t]+1;
            if(mk[x]) ans=max(ans,dis[x]);
         }
     }
}
   cout<<(ans+1)/2<<'\n';
}
int main()
{
   ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
   int t;cin>>t;
   while(t--) solve();
}

Yangmrl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
codeforces round 962 (div. 3).docx
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
codeforces round 962 (div. 3) .zip
07-28
Codeforces Round 962 (Div. 3) 是一场编程竞赛，旨在测试参赛者在算法和数据结构方面的能力。由于篇幅限制，我将对这场竞赛中的几个关键问题进行详细解析，但请注意，由于具体实现细节可能因题目而异，且无法在此...
codeforces周赛div3#855记录
IT OR 考公？
03-03 1265
从div4，AC，0题(2023-1-1) 到div4，AC，8题(目标) (希望2023-8-1之前实现)
Codeforces Round 903 div3 D-G
m0_73500785的博客
10-14 238
个人练习记录
7 E. Block Sequence
weixin_61426225的博客
02-20 840
非常不错的一道dp题目。给自己的启发是dp的顺序不止能从前往后，也可以逆序，只要初始化好状态。
Codeforces Round 903 (Div. 3) A~F
IH_LZH的博客
10-14 448
暴力，字符串arr1的长度不超过25，暴力枚举即可。
Codeforces Round 903 (Div. 3)赛后总结
weixin_73550568的博客
10-13 181
那么最后每个元素的质因子的种类个数也一定相同，所以我们把数组的所有质因子存起来，然后分配给n个元素，如果不能分配给n个元素，即某一类质因子个数不能整除n，那么no，否则yes。思路：先排个序，然后由于最后线的长度相同，那么两条长的一定的那条最短的长度的倍数，然后算出那个倍数x，操作x-1次，看是否超过3.我们可以不删除第i个：让第i个作为区间的起点，dp[i]=min(dp[i],dp[i+a[i]+1]);我们可以删除第i个：dp[i]=dp[i+1]+1，对答案贡献1；
Codeforces Round 903 (Div. 3)A~F
weixin_62701031的博客
10-14 705
题意:字符串s每次操作后变成s+s，问能否操作若干次是t是s的字串。思路：数据范围很小，len(s)和len(t)最大25，要么如果枚举到len(s)长度大于等于len(t)的二倍，还没有出现答案，之后就不会出现答案。故需要枚举log2(50)上取整次，即六次。
Codeforces Round 962 (Div. 3) a~d题解
2402_82472978的博客
07-27 399
Codeforces Round 962 (Div. 3)a~d的思路题解
Codeforces Round 895 (Div. 3)A~E题解
gyeolhada的博客
09-08 542
Codeforces Round 895 (Div. 3)ABCDE题解
CodeForces Round 925 Div.3 A-F 题解
smart_stupid的博客
02-14 1239
对于每一张截图，除开第一个数字，对于每一个剩下的数字，我们往后面的一个数字建一条有向边，不需要建多条，因为其他的关系可以通过这些边推导出来。我们选择每一种填充颜色，因为要覆盖整个序列，所以只有前缀和后缀才关系到我们的代价，对于当前数，一直找，知道找到数组前缀和后缀里的所有元素都和当前数相等，剩下的就是我们要覆盖的。对于每一个找过的元素，记录下来，不再讨论。如果遍历完都没有退出，就表明有解，输出答案，走人。我们发现，对于每一张截图，除开第一个数字，如果。大，最后统计答案位数，判断输出，完结撒花。
Codeforces Round 955 Div.2 A~D
m0_73486820的博客
06-27 1062
Codeforces Round 955 Div.2 A~D 题解
Codeforces Round #628 (Div. 2) A~~D
01-03
A #include using namespace std; typedef long long ll; int main(){ int t; cin>>t; while(t--){ ll x; cin>>x; cout<<1>>t; while(t--){ st.clear(); ll n; cin >>n; ll re
Codeforces Round 964 (Div. 4).pdf
08-07
A~G
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 777
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 331
基于Pygame和PIL的迷宫生成器
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 530
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 319
哈希表解决存在重复元素二问题
noip2001数的划分
no_play_no_games的博客
08-18 187
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
Codeforces Round 894 (Div. 3)
08-29
Codeforces Round 894 (Div. 3) 是一个Codeforces举办的比赛，是第894轮的Div. 3级别比赛。它包含了一系列题目，其中包括题目E. Kolya and Movie Theatre。 根据题目描述，E. Kolya and Movie Theatre问题要求我们给定两个字符串，通过三种操作来让字符串a等于字符串b。这三种操作分别为：交换a中相同位置的字符、交换a中对称位置的字符、交换b中对称位置的字符。我们需要先进行一次预处理，替换a中的字符，然后进行上述三种操作，最终得到a等于b的结果。我们需要计算预处理操作的次数。 根据引用的讨论，当且仅当b[i]==b[n-i-1]时，如果a[i]!=a[n-i-1]，需要进行一次操作；否则不需要操作。所以我们可以遍历字符串b的前半部分，判断对应位置的字符是否与后半部分对称，并统计需要进行操作的次数。 以上就是Codeforces Round 894 (Div. 3)的简要说明和题目E. Kolya and Movie Theatre的要求。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [Codeforces Round #498 (Div. 3) （A+B+C+D+E+F）](https://blog.csdn.net/qq_46030630/article/details/108804114)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [Codeforces Round 894 (Div. 3)A~E题解](https://blog.csdn.net/gyeolhada/article/details/132491891)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值