CSP第一次模拟

A题

问题描述：

一个圆环上有一个指针，最初指向字母a。咕咕东每次可以顺时针或者逆时针旋转一格。例如，a顺时针旋转到z，逆时针旋转到b。咕咕东手里有一个字符串，但是他太笨了，所以他来请求你的帮助，问最少需要转多少次。
输入一行字符串，输出最少要转的次数。
圆环如下图所示

思路

输入一个字符串用string保存，依次遍历每个字符计算每次从基准字符移动所需要的次数，也就是判断移动方式是顺时针还是逆时针转动，这里我采用计算两字符之间的差模26和13的大小关系判断，如果大于13数目逆时针转动次数会更少，否则则采用顺时针转动，之后再更新基准字符，进行下一个字符的计算，直到字符串结尾。

代码

#include
using namespace std;
  
string str;
int main()
{
 int count=0;
 cin>>str;
 char now='a';
  for(int i=0;i<str.size();i++)
  {
   if((str[i]-now+26)%26>13)
   {
    count+=(26-((str[i]-now+26)%26));
   }
   else count+=((str[i]-now+26)%26);
   now=str[i];
  }
 cout<<count<<endl;
 return 0;
 
}

总结

这道题难度不大，利用模26就能轻松解决

B题

问题描述

咕咕东每天需要买ai个生煎。但是生煎店为了刺激消费，只有两种购买方式：①在某一天一次性买两个生煎。②今天买一个生煎，同时为明天买一个生煎，店家会给一个券，第二天用券来拿。没有其余的购买方式，这两种购买方式可以用无数次,但是咕咕东是个节俭的好孩子，他训练结束就走了，不允许训练结束时手里有券。咕咕东非常有钱，你不需要担心咕咕东没钱，但是咕咕东太笨了，他想问你他能否在考试周每天都能恰好买ai个生煎。
输入考试周的天数n（1<=n<=100000），以及n天每天要买的生煎的数量ai（0<=ai<=10000）。

思路

这里可以采用简单模拟，按照每一天想吃的生煎数量的奇偶，结合前一天的购买方式进行判断决定采用哪一种购买方式，这里需要对最后一天进行特判.
这里采用flag表示前一天的购买方式，0表示采用方式1,1表示方式2 ，手里目前有一个券，当天必须使用，flag2表示是否发生了有券而没用的情况，如果出现则输出“NO”,对于最后一天只能采用方式1，即减去昨天的券后必须是偶数，否则输出“NO”.

代码

#include
using namespace std;
  
//string str;

int main()
{
	int n,temp;
	cin>>n;
	bool flag=0,flag2=1;
	for(int i=0;i<n-1;i++)
	{		
		cin>>temp;
 		if(flag2)
		{
			if(flag)
			{
				temp-=1;
				if(temp<0)
				{
					flag2=0;//flag2倒了 
	 			}
				flag=0;
			}
			if( temp%2)flag=1;//奇数，采用方案二，立flag。 
		}
	}
		cin>>temp;
	if(flag2)
	{
 		if(flag)
		{
			temp-=1;
			if(temp<0)
			{
				flag2=0;
 			}
			flag=0;
		}
	}
	if(!flag2||temp%2)cout<<"NO"<<endl;
	else cout<<"YES"<<endl;	
	return 0;
	
}

总结

这道题思路清晰，但是细节需要考虑清楚，刚开始没仔细想就动手写，还好在多测试了几组数据才发现了flag2的问题，加上后就解决了

C题

问题描述

宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂n次，每次分裂后会在分裂方向前进ai个单位长度。
计算出共有多少个位置会被"降智打击"
输入宇宙射线会分裂的次数n（n<=30）,以及第i次分裂的宇宙射线会在它原方向上继续走长度ai（ai<=5）。
分裂方式如图所示：

思路

我采用的是BFS的思路，用一个四维数组记录是否经过过该点，当经过了该点便舍弃该点，否则就将该点加入队列，这里采用set储存点，就省去了判重的步骤，最后输出set的size就行了

代码

#include 
#include
#include
#include
using namespace std;
//bool vis[400][400];
bool revis[400][400][8][33];
int length[100];

struct point
{
    int x;
    int y;
    int d;//0-7for 8个方向  0 up 1 ul 2 r 3dr 4 down   
    point(int a,int b,int c=0):x(a),y(b),d(c){};
    point(){};
    bool operator <(const point & a) const
	{
		if(x==a.x)return y<a.y;
		return x<a.x;
	}
};
set<point>mp; 
struct xy
{
    int x;
    int y;
}dxdy[8];
void initial()
{
    dxdy[0].x=0;
    dxdy[0].y=1;
    dxdy[1].x=1;
    dxdy[1].y=1;
    dxdy[2].x=1;
    dxdy[2].y=0;
    dxdy[3].x=1;
    dxdy[3].y=-1;
    dxdy[4].x=0;
    dxdy[4].y=-1;
    dxdy[5].x=-1;
    dxdy[5].y=-1;
    dxdy[6].x=-1;
    dxdy[6].y=0;
    dxdy[7].x=-1;
    dxdy[7].y=1;
}
int main()
{
   // memset(vis,0,sizeof(vis));
	memset(revis,0,sizeof(revis));
    int n;
    cin>>n;
    initial();
    for(int i=0;i<n;i++)
    {
        cin>>length[i];
    }
    queue<point> q;
    point start(200,200,0);
    int ans=0;
    q.push(start);
    for(int j=0;j<n;j++)
    {
        int k = q.size();
        while(k--)
        {
            point newpos = q.front();
            q.pop();
            for(int i=1;i<=length[j];i++)
            {
                newpos.x += dxdy[newpos.d].x;
                newpos.y += dxdy[newpos.d].y;
 
               // point  t(newpos.x,newpos.y);
				mp.insert({newpos.x,newpos.y});
            }
            if(j!=n-1)
            {
                if(revis[newpos.x][newpos.y][(newpos.d+1)%8][j]==0)
                {
                    point p1(newpos.x,newpos.y,(newpos.d+1)%8);
                    q.push(p1);
                    revis[newpos.x][newpos.y][(newpos.d+1)%8][j]=1;
                }
                if(revis[newpos.x][newpos.y][(newpos.d+7)%8][j]==0)
                {
                    point p2(newpos.x,newpos.y,(newpos.d+7)%8);
                    q.push(p2);
                    revis[newpos.x][newpos.y][(newpos.d+7)%8][j]=1;
                }
            }
        }
    }
    cout<<mp.size();
}

总结

这道题让我深切感受到了码力不足，将近一个小时的时间才搞了一个暴力bfs算法强行模拟，果不其然就超时了，事后请教高人，在高人指点下找到正确的去重办法，听说还有一种dfs的办法，还要进行学习啊。