CF Round #713 (Div. 3)【A-G】全题解

最新推荐文章于 2021-09-14 23:12:39 发布
最新推荐文章于 2021-09-14 23:12:39 发布
阅读量121 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41201328/article/details/116310699
版权

A题：

直接数次数。

B题：

模拟一下，不同行列的放在一起看，相同行列的放在一下看，注意细节问题。

#include<cstdio>
#include<cstring>

using namespace std;


char a[404][404];
struct point{
    int x,y;
};

int main()
{
    //freopen("1.txt","w",stdout);
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        char k;
        memset(a,0,sizeof(a));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                scanf("\n%c",&k);
                a[i][j]=k;
            }
        }
        point b,c;
        b.x=b.y=0;
        c.x=c.y=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(b.x==0&&a[i][j]=='*'){
                    b.x=i;b.y=j;
                }
                else if(c.x==0&&a[i][j]=='*'){
                    c.x=i;c.y=j;
                }
            }
        }
        if(b.x==c.x){
            if(b.x-1>=1){
                a[b.x-1][b.y]='*';
                a[c.x-1][c.y]='*';
            }
            else if(b.x+1<=n){
                a[b.x+1][b.y]='*';
                a[c.x+1][c.y]='*';
            }
        }
        else if(b.y==c.y){
            if(b.y-1>=1){
                a[b.x][b.y-1]='*';
                a[c.x][c.y-1]='*';
            }
            else if(c.y+1<=n){
                a[b.x][b.y+1]='*';
                a[c.x][c.y+1]='*';
            }
        }
        else if(b.x!=c.x&&b.y!=c.y){
            a[b.x][c.y]='*';
            a[c.x][b.y]='*';
        }

        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                printf("%c",a[i][j]);
            }
            printf("\n");
        }
    }
}

C题：

要求搞一个回文串，首先将已经存在的字母两边做一个对称的样子出来，然后剩下的在用0或1来搞，注意期间判断不可行的情况。还有一个坑点就是如果给的串已经是回文串需要特判一下。

#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=2e5+10;
char z[MAXN];
int main()
{
    //freopen("1.txt","w",stdout);
    int t;
    bool ans=1;
    scanf("%d",&t);
    while(t--){
        int a,b;
        scanf("%d%d",&a,&b);
        scanf("%s",z+1);
        int len=strlen(z+1);
        if(a+b!=len){
            printf("-1\n");
            continue;
        }
        int la=0,lb=0;
        for(int i=1;i<=len;i++){
            if(z[i]==z[len-i+1]){
                if(z[i]=='0')la++;
                if(z[i]=='1')lb++;
            }
        }
        if(la==a&&lb==b&&la+lb==len){
            for(int i=1;i<=len;i++){
                printf("%c",z[i]);
            }
            printf("\n");
            memset(z,0,sizeof(z));
            continue;
        }
        ans=1;
        for(int i=1;i<=len;i++){
            if(z[i]!='?'&&z[len-i+1]!='?'&&z[i]!=z[len-i+1]){
                ans=0;
                break;
            }
            if(z[i]=='1'&&z[len-i+1]=='?'){
                z[len-i+1]='1';
            }
            if(z[i]=='0'&&z[len-i+1]=='?'){
                z[len-i+1]='0';
            }
        }
        int cnt_a=0,cnt_b=0,cnt=0;
        for(int i=1;i<=len;i++){
            if(z[i]=='1')cnt_b++;
            if(z[i]=='0')cnt_a++;
            if(z[i]=='?')cnt++;
        }
        if(cnt_b>b||cnt_a>a)ans=0;
        a=a-cnt_a;
        b=b-cnt_b;
        if(a+b!=cnt) ans=0;
        if(cnt%2==0&&a%2==1&&b%2==1){
            ans=0;
        }
        if(!ans){
            printf("-1\n");
            continue;
        }
        if(z[len/2+1]=='?'&&cnt%2==1){
            if(a%2==1){
                z[len/2+1]='0';
                a--;
            }
            else if(b%2==1){
                z[len/2+1]='1';
                b--;
            }
        }
        for(int i=1;i<=len;i++){
            if(z[i]=='?'){
                if(a>0){
                    z[i]='0';
                    a--;
                    if(a>0&&z[len-i+1]=='?'){
                        z[len-i+1]='0';
                        a--;
                    }
                    continue;
                }
                if(b>0){
                    z[i]='1';
                    b--;
                    if(b>0&&z[len-i+1]=='?'){
                        z[len-i+1]='1';
                        b--;
                    }
                    continue;
                }
            }
        }
        for(int i=1;i<=len;i++){
            printf("%c",z[i]);
        }
        printf("\n");
        memset(z,0,sizeof(z));
    }
}

D:

先将b数组排序，a数组元素的和只能是b中倒数第一个或者倒数第二个。先记录一遍b数组前n+1个数组的和，然后假设倒数一个是的话，就依次枚举1–n+1个元素，判断sum(N+1)-b[i]==b[n+2]如果满足条件就找答案了。如果是倒数第二个的话直接sum(N+1)-b[N+1]==b[N+1]，如果满足就是答案

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
const int MAXN=2e5+10;
long long int b[MAXN];
int main()
{
    int _;
    scanf("%d",&_);
    while(_--){
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n+2;i++){
            scanf("%lld",&b[i]);
        }
        sort(b+1,b+1+n+2);
        long long int sum=0;
        for(int i=1;i<=n+1;i++){
            sum+=b[i];
        }
        int p=0;
        for(int i=1;i<=n+1;i++){
            if(sum-b[i]==b[n+2]){
                p=i;
                break;
            }
        }
        if(!p&&sum-b[n+1]==b[n+1])p=n+1;
        if(p){
            for(int i=1;i<=n+1;i++){
                if(i==p)continue;
                printf("%lld ",b[i]);
            }
            printf("\n");
        }
        else printf("-1\n");
    }

}

E:

可以用枚举加剪枝的方法来做。

#include<cstdio>
#include<cstring>
using namespace std;

const int MAXN=505;
bool vis[MAXN];
int ans[MAXN];
int n;
bool dfs(int beg,int f,int r,int now,int sum){
    if(f==r+1&&now==sum){
        int p=beg;
        for(int i=1;i<=n;i++){
            if(vis[i]){
                ans[beg]=i;
                beg++;
            }
        }
        return true;
    }
    if(now>=sum&&f<=r)return false;  //剪枝
    int cnt=r-f+1,k=n,s=0,c=0;
    while(c<cnt){
        if(!vis[k]){
            s+=k;
            c++;
        }
        k--;
    }
    if(now+s<sum)return false;

    for(int i=1;i<=n;i++){
        if(!vis[i]){
            vis[i]=1;
            if(dfs(beg,f+1,r,now+i,sum))return true;
            vis[i]=0;  //回溯
        }
    }
    return false;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int l,r,s;
        scanf("%d%d%d%d",&n,&l,&r,&s);
        if(!dfs(l,l,r,0,s))printf("-1\n");
        else{
            for(int i=1;i<=n;i++){
                if(ans[i]==0){
                    for(int j=1;j<=n;j++){
                        if(!vis[j]){
                            ans[i]=j;
                            vis[j]=1;
                            break;
                        }
                    }
                }
            }
            for(int i=1;i<=n;i++){
                printf("%d ",ans[i]);
            }
            printf("\n");
        }
        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));
    }
}

F:

此题为记忆化搜索或DP，每个工作等级只有两种状态，一是一直工作直到钱足够买电脑，二是足够上课。这里注意，如果是要上课的话必须钱一够就上，否则答案必不是最小的。

#include<cstdio>
#include<algorithm>
using namespace std;


const int MAXN=2e5+10;

int a[MAXN],b[MAXN];
int mem[MAXN];
int n,c;

int dfs(int lv,int sum){

    int w=(c-sum)/a[lv];
    if(w*a[lv]<(c-sum))w++;
    if(lv!=n){
        int edu=(b[lv]-sum)/a[lv];
        if(edu*a[lv]<(b[lv]-sum))edu++;
        return mem[lv]=min(w,dfs(lv+1,(sum+edu*a[lv])-b[lv])+edu+1);
    }
    else return mem[lv]=w;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&c);
        for(int i=1;i<=n;i++)scanf("%d",&a[i]);
        for(int i=1;i<n;i++)scanf("%d",&b[i]);
        printf("%d\n",dfs(1,0));
    }
}

G:

首先暴力打表，时间复杂度是10^7 ^*(1+1/2+1/3+1/4+……1/107^）算是卡常过了，然后记录一遍C的值，查询答案是O(1)

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=1e7;
int d[MAXN+5];
int ans[MAXN+5];
void solve(){

    for(int i=1;i<=MAXN;i++){
        for(int j=1;j*i<=MAXN;j++){
            d[i*j]+=j;
        }
        ans[i]=MAXN;
    }
    for(int i=1;i<=MAXN;i++){
        if(d[i]>MAXN)continue;
        ans[d[i]]=min(ans[d[i]],i);
    }
}
int main()
{
    solve();
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        if(ans[n]==MAXN)printf("-1\n");
        else printf("%d\n",ans[n]);
    }
}
Simon-Venn
关注
专栏目录
【Codeforces Round#620 (Div. 2)】B. Longest Palindrome 题解
01-06
He learned that a palindrome is a string that is the same as its reverse. For example, strings “pop”, “noon”, “x”, and “kkkkkk” are palindromes, while strings “moon”, “tv”, and “abab” ...
【解题报告】CF DIV3 #ROUND 713 A~E
鱼竿钓鱼干
04-12 334
【解题报告】CF DIV2 #ROUND 713 A~E 比赛链接 A. Spy Detected! 思路 代码 // Problem: A. Spy Detected! // Contest: Codeforces - Codeforces Round #713 (Div. 3) // URL: https://codeforces.com/contest/1512/problem/A // Memory Limit: 256 MB // Time Limit: 2000 ms // FishingRod
Codeforces Round #635 (Div. 2)D. Xenia and Colorful Gems
01-03
题解：6nlogn，先sort三个数组a,b,c, 六次枚举二分查找，再每次min找最小值，例如:先固定数组a，再在数组b,c中利用lower_bound找到第一个大于等于a[i]的数， #pragma GCC optimize(2) #include #define ll long long...
roymondliao#Algorithm_Interview_Notes-Chinese#题解-面试真题1
07-25
题解-面试真题记录一些暂时没找到原型的面试真题给定 n 个[0,n)区间内的数，统计每个数出现的次数，不使用额外空间给定 n 个[0,n)区间内的数，统计每个数
3章 多级放大电路题解.rar-综合文档
05-10
《3章 多级放大电路题解》是一个关于电子工程领域的文档，主要涵盖了多级放大电路的相关知识。在本章中，我们将会深入探讨多级放大电路的基本概念、设计原则以及实际应用。多级放大电路是由两个或多个单级放大器串联...
DAG模型
qq_41201328的博客
03-08 1352
概念： DAG即有向无环图。因为其有向性和拓扑序很相似，都是在定义优先级，其实拓扑序也是无环图，这好像也是他们的共同点。由此缘故很多DAG+dp问题可以转化为拓扑序+dp问题。比如紫书上的嵌套矩形问题，巴比伦塔问题。但是比如紫书上的硬币问题，就必须用DAG求最短最长路。可以说DAG只是一种特殊的图，并没有起点，是去中心化的。 构建： 需要显化隐式图，并且构建有向边，这一步是将问题图论化，并将问题的解转化为DAG上求最短最长路问题。 资料 有向无环图是描述一项工程或系统的进行过程的有效工具。除最简单的情况之
CF1516B AGAGA XOOORRR【异或运算+区间操作+暴力枚举】
qq_41201328的博客
04-27 336
题目大意： 给一个序列，序列中每两个相邻的元素可以做异或运算，然后这两个元素消失，得到的结果替换他们的位置。如果最后序列中所有元素都相等并且序列长度至少为2，则YES否则NO。 思路： 一定要看清题目，一是相邻，二是序列长度至少为2，如果序列中有4个元素相等，可以转化为2个元素相等，如果有三个元素相等，则无法用两个元素相等的方法来判断，所以就判断2个元素相等和3个元素相等的情况就行了。用区间的方式记录按位异或的结果。最后判断输出即可。时间复杂度为O(N^2)，不是最好的，其实还可以用O（N）的方法来做。但第
2021-SZTU第一届acm校赛总结
qq_41201328的博客
05-16 330
关于题目： 我们队上来找到签到题，一个上去签，我和另外一个继续看题，我从后往前，他从前往后。后边的题目普遍是中文，难度也更高。然后他们两个就讨论一题签一题，干掉四题。我看了一道区间操作相关的题目，最近刚好学了线段树，感觉可以搞一搞。然而我上来就排除了线段树的做法，转而用一种较为奇特的差分数组和前缀和数组来模拟。（后来教练说这题是线段树。。。。不过他队友用奇奇怪怪的思路解决了）。然后我就在这道题上卡了很久，队友一直在写前几题，似乎比较顺利，最后解决了几个bug之后队友让我去看看别的题，我看bug一时半会找不出
POJ-1050 To the MAX题解
qq_41201328的博客
03-16 271
题目大意： 给定一个矩阵，要求矩阵中最大子矩阵和。N<=100 如输入： 4 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 输出： 15 思路： 法一：这题是到数据范围不是很严谨的一道题，虽说N<=100，但是N^4仍然可以过。 复习一下二维前缀和的知识 dp[i][j]=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]; 若要求左上角为（i，j）右下角为（x，y）的矩形和则为：dp[x][y]-dp[x][j-1]-dp[i-1][y]+dp
Power Calculus【经典IDA*】
qq_41201328的博客
04-21 264
题目大意： 给一个数N，代表x的N次幂，起初集合内只有元素x，集合内任意元素做乘法（可以自乘可以和其它元素相乘）得到一个新的元素并放入集合内。要求最少做多少次乘法和以得到N次幂。 思路： 最初做题时用贪心的做法发现有些答案不对，转而用暴力IDA的做法，不过还是夹杂着贪心的思路，如果当前的幂小于给定幂，就只做乘法，只有当前幂大于给定幂时才做除法。不过这种方法对与某些个例来说是算不出正确答案的。所以只能是不管当前幂大于还是小于给定幂，乘除法都要做，虽然用了IDA，但在数据量为1000时还是比较慢，大概3~4s
CodeForces 740 div 2（A-E）
qq_41201328的博客
09-14 257
codeforces 740div2 A. Simply Strange Sort 题目思路： 给一个数组aaa，下标为奇数时，满足ai>ai+1a_i>a_{i+1}ai​>ai+1​时，更改ai和ai+1a_i和a_{i+1}ai​和ai+1​的位置，ans++ans++ans++,并对所有下标为奇数的序列重复这种操作。下标为偶数时也是同样操作。操作顺序起点从111到nnn，直到整个序列是一个有序序列就停止，输出ansansans的值（如果序列已经有序则为000）。这道题第一次做有好多
Unorder_map和Hash
qq_41201328的博客
03-08 235
引言： 同一个题目： 上边是unorder_map，下边是手写hash表。速度上unorder_map比hash慢了将近10倍，但代码量是hash的一半。在这个题目中，还有种二分查找的做法时间复杂度是O(N2logN)，Hash的效率是O(N2),可以看出unorder_map的速度比二分稍快一点。但时间效率上Hash的效率是最高的。 这个图是二分查找做法 Hash： 哈希表的作用是查找某个值是否存在，可以类比桶排序。 哈希表的构建需要两个数组和一个常数分别是HashMask[Hashsize]，Has
HDU-1560 DNA sequence【构造答案+IDA*剪枝】
qq_41201328的博客
04-24 225
题目大意: 给N个字符串，求一个最短序列能否将N个字符串包含。输出最短序列的长度。 思路： 可以构造一个最短序列，然后判断能否将所有序列包含进去。然后用IDA*剪枝（这到没错）。构造的过程并不复杂，因为只涉及4个碱基。再有就是回溯的问题，这里需要对每个字符串设置一个指针，用于判断包含关系。最后的包含关系肯定是所有字符串的指针都走到了最后一个元素。可以用数组来存每个字符串当前的指针位置，但是每个状态有不一样，这里可以用一个数组参数传递到下一个状态上，这样就避免了回溯麻烦的问题产生。 反思： 这个构造确实巧妙，
P1006 [NOIP2008 提高组] 传纸条 题解
qq_41201328的博客
03-16 219
题目大意： 给定一张n*n的图,要求从左上角走到右下角,再从右下角走到左上角。每个点都有一个值,要求最大路径值，并且来回的路不能重复的点。 思路： 朴素做法是四维数组，dp[1][2][3][4]前两维是第一个点的坐标后两维是第二个点的坐标。 反思： 有个疑问，为什么最后的输出顺序是dp[n][m-1][n-1][m]而不能是dp[n-1][m][n][m-1]。 代码如下： #include<cstdio> #include<algorithm> using namespace
CF#722 (Div2) It‘s a bird! No, it‘s a plane! No, it‘s AaParsa! 详细题解
qq_41201328的博客
06-12 197
题目大意： 给定一张有向图。每条边可以有这样的操作：如果一条边a->b=c，即从a指向b，边权为c。那么有a->(b+1)%n=c+1，即可以从a指向(b+1)%n=c+1。即输入的图只是初始状态，每条边每间隔1s都会指向不同的终点。要求在这张图上任意两点的最短距离。 思路： 此题唯一不容易处理的是“等待”这个操作，那么先考虑不等待的情况， If(Graph[i][j]){ //I与j相连 To=d[i]+j //即走到这条边时，终点的位置 d[to]=min(d[to],d[i]+Gr
HDU 2102 A计划（BFS+细节维护）
qq_41201328的博客
05-08 188
一道很裸的BFS，看时间复杂度看可以用DFS+剪枝就很神奇。 第一次做的时候维护了很多量，比如时间在此题中是一个重要的量，但是不用时刻维护，只需要维护走到当前位置需要多少天，最后找到P是多少天（如果能的话），比较找到P的天数和给定的天数即可。还有一个问题就是图的构建，开始我将N开大两倍，发现这样做有很严重的边界判断问题，容易出现bug还使得代码量增加，直接再开一维能够避免上述情况。此题还有一个教训是hdu上有个误导性样例，除非万不得已不要看discuss，简直有毒。 总之此题走出了很多坑，是到不错的题目，B
Uva 1220 Party at Hali-Bula（最大独立子集问题）
qq_41201328的博客
05-11 186
题目大意： 给一个图，要求相邻节点不能同时选择，求最多能选出多少个节点，其次，判断最大节点数的情况是否唯一。 思路： 即求最大独立子集。在此基础上再判断情况唯一就行。 反思： 起初写了一个暴力判断情况唯一的，再一个节点下枚举判断每一个子节点是否情况唯一。这个代码再poj和hdoj上都过了，再uva上超时了，索性照着紫书上的方法再开一个vis数组再做一次dp。紫书开了一个二维数组a[i][0/1]来表示i节点选或不选得到的结果。如果不开二维数组的话，也可以开两个数组s[i]，gs[i]，分别记录子节点的答案和
第十八届浙大城市学院程序设计竞赛 D-LCA On N-ary Tree
qq_41201328的博客
03-22 184
题目大意： The N-ary tree is a tree that each node has exactly nn_{}n​ child nodes. You are given an N-ary tree with infinite nodes, each node is numbered from 11_{}1​ to infinity according to the level order(from left to right, level by level). Given the numbe
第十八届浙大城市学院程序设计竞赛 F-Palindrome
qq_41201328的博客
03-22 175
题目大意: You are given a string s​ of n​ lowercase letters. You have to delete exactly two letters from s​ , determine whether the string can become a palindrome after the change. Definition of palindrome: If a string s​ of n​ lowercase letters is a palindrom
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问题要求我们...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值