Codeforces Round #534 (Div. 2)题解

最新推荐文章于 2022-11-19 18:52:08 发布

weixin_34088583

最新推荐文章于 2022-11-19 18:52:08 发布

阅读量91

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/fly-white/p/10308260.html

版权

Codeforces Round #534 (Div. 2)题解

A. Splitting into digits

题目大意

将一个数字分成几部分，几部分求和既是原数，问如何分可以使得分出来的各个数之间的差值尽可能小

解题思路

将n分成n个1相加即可

AC代码

#include<cstring>
#include<string>
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
    int n;
    scanf("%d",&n);
    printf("%d\n",n);
    for(int i=1;i<=n;i++)
    {
        printf("1");
        if(i==n) puts("");
        else printf(" ");
    }
}

B. Game with string

题目大意

给出一段字符串，相同且相邻的字母可以消去，消去后被消除的相邻字母的两侧的字符串重新连接在一起，如可以消除奇数次输出"Yes"，如可以消除偶数次输出"No"

解题思路

读取字符串后用栈对原字符串进行处理，遍历字符串，如最新的一个字符与栈顶元素相同则弹出栈顶元素，否则将当前字符插入栈中，统计总过弹出了多少次，即是可以消除的次数

AC代码

#include<cstring>
#include<string>
#include<iostream>
#include<cstdio>
#include<stack>
#include<cstring>
using namespace std;
const int size=1e5+5;
char s[size];
int main()
{
    scanf("%s",s);
    int len=strlen(s);
    stack<char> sta;
    int cnt=0;
    for(int i=0;i<len;i++)
    {
        if(!sta.empty())
        {
            char t=sta.top();
            if(t==s[i]) {
            sta.pop();
            cnt++;
            continue;} 
        }
        sta.push(s[i]);
    }
    if(cnt%2) puts("Yes");
    else puts("No");
}

C. Grid game

题目大意

给出一个4*4的方阵图，和一串字符串字符串中有1和0两种字符分别代表"1*2"与"2*1"牌子，0代表竖着的牌子，1代表横着的牌子，当一行或者一列被填充满了之后其上将会消去，问若要将字符串顺序的牌子依次入这个方阵图应当如何放置.

解题思路

第奇数个竖的总之先放在左上角(1,1)的位置,第奇数个横的总是先放在右下角(4,3)位置，当出现第偶数个竖着的牌子则将其放在(3,1)，则其就会与提前放置好的奇数个竖牌子消去，当出现第偶数个横的牌子则将其放在(4,1)，这样就会与提前放置好的奇数个横牌子消去

AC代码

#include<cstring>
#include<string>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
char s[1005]; 
int main()
{
    scanf("%s",s);
    int len=strlen(s);
    int v=0,h=0;
    for(int i=0;i<len;i++)
    {
        if(s[i]=='0')
        {
            if(v==0) printf("1 1\n"),v=1;
            else  printf("3 1\n"),v=0;
        }
        else
        {
            if(h==0) printf("4 3\n"),h=1;
            else printf("4 1\n"),h=0;
        }
    }
}

D. Game with modulo

题目大意

交互题.让你猜一个数字，每次输出x，y，系统会返回x当\(x\%a\ge y\%a\)当\(x\%a<y\%a\)会返回y，题目要求在60次询问内，得出答案

解题思路

首先设定函数\(f(x)=x\%a\)其函数图像为连续的边长为a的等腰直角三角形.现通过设定一个l=0,r=1,通过每次l=r,r=2*r观察其是否有\(f(r)<f(l)\)，若有则可以固定出\(f(x)\)的一个周期,再对这个区间进行二分即可

AC代码

#include<iostream>
#include<string>
using namespace std;
bool check(int l,int r)
{
    char c;
    cout << "? " << l << " " << r << endl; cin >> c;
    if(c=='y') return true;
    else return false;
}
int main()
{
    string s;
    while(cin>>s&&s=="start")
    {
        int x=0,y=1;
        while(check(x,y))
        {
            x=y;
            y*=2;
        }
        int l=x,r=y,ans=x+1;
        while(l+1<r)
        {
            int mid=(l+r)/2;
            if(check(l,mid))
            {
                l=mid;
                ans=mid+1;
            }else{
                r=mid;
            }
        }
        cout<<"! "<<ans<<endl;
        fflush(stdout);
    }
}

E. Johnny Solving

题目大意

给出一连通图，其中不存在自环和重边，其有n个节点m条边，给出一个参数k，若存在长度大于等于\(\frac{n}{k}\)则输出“PATH”，并将那条路输出，若存在k个满足周长不被3整除，且每个圆都存在一个只属于这个圆的点则输出“CYCLES”并将k个圆的组成输出，如都不存在则输出-1

解题思路

首先我们需要明确一点，即或是圆或是路，其必然存在一个.假设不存在路，则一条不行成环的路的最长长度为\(\frac{n}{k}-1\)即环的周长的最大值为\(\frac{n}{k}-1\),因此至少可以构成k个环，且每个环都可以持有一个独一无二的点，且对于每个点而言其度至少未3，因此，其至少能有两个后驱，假如有一个后驱再回到起点的长度不是三的倍数，则有一个解，若两个均是3的倍数，则这两个点之间的距离-2也会是3 的倍数，因此可以从原本的点出发，通过一个后驱到达另一个后驱则必有3的倍数+1则必然不被3整除.路总是很容易找到的，直接对图进行暴力搜索即可，访问过的点进行标记，而总是不访问已经访问过点点则可以保证不成环.对环进行搜索时，首先对每次开始搜索的点打上标记并且加入一个路径vector中，因为环只能通过再次访问一个已经访问过的点得到，因此对每一个点的后驱进行遍历，若存在未访问的点则优先将点访问全，如都已访问全则选取两个后驱，则按照上面说的判断周长是否被3整除的思路判断出是否存在周长不为3的倍数的环即可.完成后再进行回溯，将加入的点从vector中弹出即可.

AC代码

By FlyWhite, contest: Codeforces Round #534 (Div. 2), problem: (E) Johnny Solving, Accepted, #
 #include<vector>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int size=25e4;
vector<int> g[size];
bool vis[size];
vector<int> path;
int pre[size];
int cir;
bool find_path(int v,int sz)
{
    vis[v]=1;
    path.push_back(v);
    if(path.size()>=sz) return true;
    for(auto u:g[v])
    {
        if(!vis[u])
        if(find_path(u,sz)) return true;
    }
    path.pop_back();
    return false;
}
void dfs(int v,int f)
{
    vis[v]=1;
    pre[v]=path.size();
    path.push_back(v);
    int flag=0;
    for(auto u:g[v])
    {
        if(!vis[u]) {flag=1;break;}
    }
    if(flag)
    {
        for(auto u:g[v])
        {
            if(!vis[u])
            {
                dfs(u,v);
            }
        }
    }
    else if(cir>0)
    {
        int fax=-1,fay=-1;
        for(auto u:g[v])
        {
            if(u==f) continue;
            if(fax==-1) fax=u;
            else if(fay==-1)
            {
                fay=u;
                break;
            }
        }
        if(pre[fax]<pre[fay]) swap(fax,fay);
        int ori=-1;
        if((pre[v]-pre[fax])%3!=2) ori=fax;
        if((pre[v]-pre[fay])%3!=2) ori=fay;
        if(ori!=-1)
        {
            printf("%d\n",pre[v]-pre[ori]+1);
            for(int i=pre[v];i>=pre[ori];i--)
            {
                printf("%d%c",path[i],i==pre[ori]?'\n':' ');
            }
        }
        else 
        {
            printf("%d\n",pre[fax]-pre[fay]+2);
            int point=pre[fax];
            printf("%d ",v);
            for(;point>=pre[fay];point--)
            {
                printf("%d%c",path[point],point==pre[fay]?'\n':' ');
            }
        }
        cir--;
    }
    path.pop_back();
}
             
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    int sz=n/k;
    if(n%k) sz+=1;
    if(find_path(1,sz))
    {
        printf("PATH\n");
        printf("%d\n",path.size());
        for(int i=0;i<path.size();i++)
        {
            printf("%d%c",path[i],i==path.size()-1?'\n':' ');
        }
        return 0;
    }
    path.clear();
    memset(vis,0,sizeof(vis));
    printf("CYCLES\n");
    cir=k;
    dfs(1,0);
    return 0;
}

转载于:https://www.cnblogs.com/fly-white/p/10308260.html