Program CSP M1

A 咕咕东的奇遇

题目描述：
咕咕东是个贪玩的孩子，有一天，他从上古遗迹中得到了一个神奇的圆环。这个圆环由字母表组成首尾相接的环，环上有一个指针，最初指向字母a。咕咕东每次可以顺时针或者逆时针旋转一格。例如，a顺时针旋转到z，逆时针旋转到b。咕咕东手里有一个字符串，但是他太笨了，所以他来请求你的帮助，问最少需要转多少次。

输入格式：
输入只有一行，是一个字符串。

输出格式：
输出最少要转的次数。

思路

显然是一个贪心问题，每一步都选择步数更少的那一边走，走到某个next节点就以该节点作为now，然后继续遍历

Answer

一开始的想法有点小偏，想左右两边一边为正一边为负，然后再用26减来减去得到结果，逻辑上也合理但有点绕

#include<iostream>
#include<math.h>
#include<map>
using namespace std;

map<char,int> p;

int main()
{
	int sum=0;
	char s[10000];
	char c='a'; 
	//存储各点的偏移量，轮盘右半部分为1~12，左半部分为-1~-12，顶为0，底为13 
    for(int i=0;i<14;i++){
    	p[c++]=i;
	}
	for(int i=14;i<26;i++){
    	p[c++]=i-26;
	}
	scanf("%s",s);
	for(int i=0;s[i]!='\0';i++){
		int q=p[s[i]];//q代表该点的偏移量 
		sum+=abs(q);//转的次数 
		//更新所有点的偏移量 
		for(char t='a';t<='z';t++){
			if(p[t]-q>13)
			p[t]=p[t]-26-q;
			else if(p[t]-q<-12) 
			p[t]=p[t]+26-q;
			else p[t]=p[t]-q;
		}
	}
	cout<<sum;
    return 0;
}

其实还有更简洁做法

#include<iostream>
#include<cstring>
using namespace std;
string s;
int sum(char c)
{
	if(c>='a'&&c<='z')
	return c-'a';
	if(c>='A'&&c<='Z')
	return c-'A';
}
int main()
{
	int a,b,ans=0;
	cin>>s;
	int l=s.length();
	int now=0;
	for(int i=0;i<l;i++)
	{
		int next=sum(s[i]);
		a=(now-next+26)%26;
		b=(next-now+26)%26;
		ans+=min(a,b);
		now=next;
	}
	cout<<ans;
	return 0;
}

B 咕咕东想吃饭

题目描述：
咕咕东考试周开始了，考试周一共有n天。他不想考试周这么累，于是打算每天都吃顿好的。他决定每天都吃生煎，咕咕东每天需要买ai个生煎。但是生煎店为了刺激消费，只有两种购买方式：①在某一天一次性买两个生煎。②今天买一个生煎，同时为明天买一个生煎，店家会给一个券，第二天用券来拿。没有其余的购买方式，这两种购买方式可以用无数次,但是咕咕东是个节俭的好孩子，他训练结束就走了，不允许训练结束时手里有券。咕咕东非常有钱，你不需要担心咕咕东没钱，但是咕咕东太笨了，他想问你他能否在考试周每天都能恰好买ai​个生煎。

输入格式：
输入两行，第一行输入一个正整数n(1<=n<=100000)，表示考试周的天数。

第二行有n个数，第i个数ai（0<=ai<=10000）表示第i天咕咕东要买的生煎的数量。

输出格式：
如果可以满足咕咕东奇怪的要求，输出"YES"，如果不能满足，输出“NO”。（输出不带引号）

思路

一开始思路偏了，或者说没想出来（哭了QAQ），因为某一天可能会买多个，所以开始思考如何遍历每种情况（即两种方案各用多少次），但这一看就不对啊，不可能这么憨的。
正确思路是：若某天需要的个数为偶数个，如果是全部按照第一种方案买的话，造成的影响仅仅是当天的，对于第二天不会有任何的影响。如果要用第二种方案的话，只能用偶数次，那么将会留偶数个生煎到第二天，其实完全可以在第二天用第一种方案代替，所以对于偶数个的情况，全部只用第一种方案买。
如果需要的是奇数个，那么只能在最后通过第二种方案买一次，即：留一个生煎到第二天。但此时，（假设这天需要买三个），完全可以用第二种方案买三次，即留三个生煎到第二天，对于这种情况，完全可以第二天用第一种方案解决一下，然后又变成了“留了一个生煎”的问题，并且得出的结果是等效的。所以对于奇数个的情况，选择只用一次方案二，剩余的全用方案一。

Answer

具体思路见注释

#include<iostream>
#include<cstdio>

using namespace std;
int a[100000];

void select(int n) {
	int t=a[0]%2;
	for(int i=1;i<n;++i) {
		a[i]-=t;
		if(a[i]<0) {
			printf("NO\n");
			return; 
		}
		t=a[i]%2;
	}
	if(t==0) printf("YES\n");
	else printf("NO\n");
	return;
}
int main() {
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;++i) {
		scanf("%d",a+i);
	}
	select(n);
	return 0;
}

C 可怕的宇宙射线

题目描述：
众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天 生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁 人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的 左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂 次，每次分裂后会在分裂方向前进 个单位长度。 现在瑞神要带着他的小弟们挑战苟狗，但是瑞神不想让自己的智商降到普通本科生 那么菜的水平，所以瑞神来请求你帮他计算出共有多 少个位置会被"降智打击"

输入描述：
输入第一行包含一个正整数 ，表示宇宙射线会分裂n次.第二行包含n个正整数a1 a2 … an，第i个数ai表示第i次分裂的宇宙射线会在它原方向上继续走多少个单位长度。

输出描述：
输出一个数 ，表示有多少个位置会被降智打击

思路

首先一开始的关键在于如何控制分裂后的方向，这里选择利用标记数组，八个方向对应各自的x，y方向上的偏移量；因为分裂次数为2^30，所以有很多的分裂情况会重复出现，所以对于“每一个点在每一方向上前进多少次”用一个四维标记数组标记，如果同样的情况重复出现，可直接忽略；对于到达过的点，用一个map标记是否到达

Answer

具体思路见注释

#include<bits/stdc++.h>
using namespace std;

char dir[]={'u','1','r','2','d','3','l','4'};
//八个方向，分别是上，右上，右，右下，下，左下，左，左上，并与下面的dx,dy对应 
const int dxx[]={0,1,1,1,0,-1,-1,-1};
const int dyy[]={1,1,0,-1,-1,-1,0,1};
bool been[1000][1000][32][8]={false};
int n,ans,a[40];
map<pair<int,int>,int> mp;

void divide(pair<int,int> p,int dx,int dy,int times,int dir)
{
 if(times==n)return;
 
 int x=p.first;
 int y=p.second;
 if(been[x][y][times][dir])return;
 else been[x][y][times][dir]=true;
 for(int i=0;i<a[times];i++)
 {
  x+=dx;
  y+=dy;
  pair<int,int> t(x,y);
  if(mp.find(pair<int,int>(x,y))==mp.end())
  {
    ans++;
    mp[t]=1;
  }
 }
 pair<int,int> u(x,y);
 divide(u,dxx[(dir+7)%8],dyy[(dir+7)%8],times+1,(dir+7)%8);
 divide(u,dxx[(dir+1)%8],dyy[(dir+1)%8],times+1,(dir+1)%8);
}
int main()
{
 cin>>n;
 for(int i=0;i<n;i++)cin>>a[i];
 pair<int,int> p(500,500);
 divide(p,0,1,0,0);
 cout<<ans;
 return 0;
}

简洁版代码：

#include<iostream>
#include<cstdio>
using namespace std;
int n,ans,a[31];
int xx[8]={0,1,1,1,0,-1,-1,-1};
int yy[8]={1,1,0,-1,-1,-1,0,1};
bool flag[600][600],vis[600][600][31][8];
void dfs(int x,int y,int now,int d)//xy表示位置，now是当前为第几次分裂，d是分裂的方向。 
{
	if(now>n||vis[x][y][now][d])
	return;
	vis[x][y][now][d]=1;
	for(int i=1;i<=a[now];i++)
	{
		x+=xx[d];y+=yy[d];
		if(!flag[x][y])
		{
			flag[x][y]=1;
			ans++;
		}
	}
	dfs(x,y,now+1,(d+7)%8);
	dfs(x,y,now+1,(d+1)%8);
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	scanf("%d",&a[i]);
	dfs(300,300,1,0);
	printf("%d",ans);
	return 0;
}