程序设计WEEK4 CSP模拟
A题 咕咕东的奇遇
咕咕东是个贪玩的孩子,有一天,他从上古遗迹中得到了一个神奇的圆环。这个圆环由字母表组成首尾相接的环,环上有一个指针,最初指向字母a。咕咕东每次可以顺时针或者逆时针旋转一格。例如,a顺时针旋转到z,逆时针旋转到b。咕咕东手里有一个字符串,但是他太笨了,所以他来请求你的帮助,问最少需要转多少次。
1. Sample Input and Output
Input
hzet
Output
31
2. 解题思路及代码
计算每个字母和前一个字母的顺时针方向间距与逆时针方向间距,小者即为此次转动的次数。求和即为转动总次数。
代码如下:
#include<iostream>
#include<string>
using namespace std;
int main()
{
int time=0;
string str;
cin>>str;
int size=str.size();
for(int i=0;i<size;i++)
{
int a,b;
if(i==0)
{
a=1;
b=str[0]-96;
} else{
a=str[i]-96;
b=str[i-1]-96;
}
int tmp=a-b;
if(tmp<0)
tmp=tmp+26;
int tmp1=b-a;
if(tmp1<0)
tmp1=tmp1+26;
if(tmp<=tmp1)
time = time + tmp;
else
time = time + tmp1;
}
cout<<time<<endl;
return 0;
}
B:咕咕东想吃饭
咕咕东考试周开始了,考试周一共有n天。他不想考试周这么累,于是打算每天都吃顿好的。他决定每天都吃生煎,咕咕东每天需要买ai个生煎。但是生煎店为了刺激消费,只有两种购买方式:①在某一天一次性买两个生煎。②今天买一个生煎,同时为明天买一个生煎,店家会给一个券,第二天用券来拿。没有其余的购买方式,这两种购买方式可以用无数次,但是咕咕东是个节俭的好孩子,他训练结束就走了,不允许训练结束时手里有券。咕咕东非常有钱,你不需要担心咕咕东没钱,但是咕咕东太笨了,他想问你他能否在考试周每天都能恰好买ai个生煎。其中(1≤n≤100000),(1≤ai≤10000)
1. Sample Input and Output
Input
4
1 2 1 2
Output
2
2. 解题思路及代码
由于买法仅有两种,要么一次性买两个,要么今天明天各买一个。
因此可以将每天的购买情况从前往后遍历并做如下处理:如果当前天购买情况为奇数,则下一天的购买数量减1。一旦遍历到的数据出现负数或者最后一天的购买数量依然为奇数,则购买方案不可行。否则可行。
代码如下:
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int * p;
p=new int[n];
for(int i=0;i<n;i++) {
cin >> p[i];
}
for(int i=0;i<n-1;i++)
{
if(p[i]<0)
{
cout<<"NO"<<endl;
return 0;
}
if(p[i]%2==1)
p[i+1]--;
}
if(p[n-1]%2==1)
{
cout<<"NO"<<endl;
return 0;
}
cout<<"YES"<<endl;
return 0;
}
C题 可怕的宇宙射线
众所周知,瑞神已经达到了CS本科生的天花板,但殊不知天外有天,人外有苟。在浩瀚的宇宙中,存在着-种叫做苟狗的生物, 这种生物天生就能达到人类研究生的知识水平,并且天生擅长CSP,甚至有全国第一的水平!但最可怕的是,它可以发出宇宙射线!宇宙射线可以摧毁人的智商,进行降智打击!
宇宙射线会在无限的二维平面上传播(可以看做一个二维网格图),初始方向默认向上。宇宙射线会在发射出一段距离后分裂,向该方向的左右45∘
45 ∘方向分裂出两条宇宙射线,同时威力不变!宇宙射线会分裂n次,每次分裂后会在分裂方向前进a个单位长度。
现在瑞神要带着他的小弟们挑战苟狗,但是瑞神不想让自己的智商降到普通本科生zjm那么菜的水平,所以瑞神来请求你帮他计算出共有多少个位置会被"降智打击”。
1. Sample Input and Output
Input
第一行n为分裂的次数
第二行n个数分别为每次分裂所传播的距离
4
4 2 3 2
Output
输出被打击到的点的个数
39
2. 解题思路及代码
在比赛中首先想到的是直接DFS,然后用二维数组来储存到达过的点。但奈何TLE,只过了4个点。
代码:
#include<iostream>
#include<algorithm>
using namespace std;
class point
{
public:
point(){}
point(int a,int b)
{
_a=a;
_b=b;
}
public:
int _a;
int _b;
};
int dx[]={0,1,1,1,0,-1,-1,-1};
int dy[]={1,1,0,-1,-1,-1,0,1};
int n;
int *p;
int map[600][600]={0};
int pathlength=0;
void addlength(point start,int direaction,int length,int i)
{
if(i==n)
return ;
point newpoint(start._a,start._b);
for(int j=0;j<length;j++)
{
newpoint._a=newpoint._a+dx[direaction];
newpoint._b=newpoint._b+dy[direaction];
if(map[newpoint._a+300][newpoint._b+300]!=0)
continue;
else {
pathlength++;
map[newpoint._a+300][newpoint._b+300]=1;
}
}
int direaction1=(direaction+1)%8;
int direaction2=(direaction+7)%8;
addlength(newpoint,direaction1,p[i+1],i+1);
addlength(newpoint,direaction2,p[i+1],i+1);
}
int main()
{
cin>>n;
p=new int[n];
for(int i=0;i<n;i++)
{
cin>>p[i];
}
addlength({0,0},0,p[0],0);
cout<<pathlength<<endl;
}
这道题目前知道的可行性解法有两个,一个是记忆化搜索,另一个是利用对称性来减少一次分裂过程。对比之下记忆化搜索码量更少更好想。
由于图的范围较小(300300),每个格子存在8个方向。在进行同一层搜索的时候,记录延伸的方向和起点为止。如果出现搜索方向相同且处于同一位置的点,可跳过该次搜索。记录数组为1503003008。
粘一下标答代码:
#include<iostream>
using namespace std;
int vis[330][330][31][8];
int mp[330][330];
int a[35];
int n,ans;
int dir[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};
void dfs(int x,int y,int cnt,int d)
{
if(vis[x][y][cnt][d]) return ;
vis[x][y][cnt][d]=1;
for(int i=1;i<=a[cnt];i++) {
x += dir[d][0], y += dir[d][1];
if (!mp[x][y]) ans++, mp[x][y] = 1;
}
if(cnt<n)
{
dfs(x,y,cnt+1,(d+1)%8);
dfs(x,y,cnt+1,(d+7)%8);
}
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
dfs(160,160,1,2);
cout<<ans<<endl;
return 0;
}