程序设计思维与实践 CSP-M1

A - 咕咕东的奇遇

一个圆环包含26个英文字母，顺时针从a到z排列，有一个指针指向a，每次可以顺时针或逆时针旋转一格。如a顺时针旋转到z，逆时针旋转到b。现在有一个字符串（长度<=10000），请输出要得到这个字符串最少需要旋转的次数。

样例输入

zeus

样例输出

18

思路
因为是26个英文字母按照顺时针方向排列，首尾相连。

由此可以想象，从当前位置current开始，先计算下一个英文字母与当前位置的距离，由小写英文字母的ASCII码，可按公式：(英文字母-97)%26来计算得到英文字母的位置。

因此可以采用abs(下一个英文字母的位置next-当前英文字母的位置current)来得到顺时针转动时两个英文字母之间的距离mi，则逆时针转动时两个字母之间的距离ma为26-mi。取min(mi,ma)来判断进行顺时针转动还是逆时针转动。

由此得到最少的转动次数。

代码

#include<iostream>
#include<string>
#include<cmath>
#include<map>
#include<queue>
using namespace std;
string str;
int N;
int NUM = 0;

void rotate()
{
	int i = 0;
	int current;
	int next;

	current = 0;
	next = (str[0] - 97) % 26;

	int mi = abs(next - current);
	int ma = 26 - mi;

	if (mi <= ma)
	{
		NUM += mi;
	}
	else
	{
		NUM += ma;
	}

	for (i=1; i < N; i++)
	{
		current = (str[i-1] - 97) % 26;
		next = (str[i] - 97) % 26;
		int mi = abs(next - current);
		int ma = 26 - mi;

		if (mi <= ma)
		{
			NUM += mi;
		}
		else
		{
			NUM += ma;
		}
	}
}

int main()
{
	cin >> str;
	N = (int)str.size();
	
	rotate();
	cout << NUM << endl;
}

B - 咕咕东想吃饭

咕咕东考试周开始了，考试周一共有n天。他不想考试周这么累，于是打算每天都吃顿好的。他决定每天都吃生煎，咕咕东每天需要买aia_iai​个生煎。但是生煎店为了刺激消费，只有两种购买方式：

①在某一天一次性买两个生煎。
②今天买一个生煎，同时为明天买一个生煎，店家会给一个券，第二天用券来拿。

没有其余的购买方式，这两种购买方式可以用无数次,但是咕咕东是个节俭的好孩子，他训练结束就走了，不允许训练结束时手里有券。咕咕东非常有钱，你不需要担心咕咕东没钱，但是咕咕东太笨了，他想问你他能否在考试周每天都能恰好买ai​个生煎。

Input
输入两行，第一行输入一个正整数n (1<=n<=100000)，表示考试周的天数。
第二行有n个数，第i个数 ai（0<=ai<=10000，表示第i天咕咕东要买的生煎的数量。

Output
如果可以满足咕咕东奇怪的要求，输出"YES"，如果不能满足，输出“NO”。
Sample Input

4
1 2 1 2

Sample Output

YES

Sample Input

3
1 0 1

Sample Output

NO

思路

如果能够满足题目中的要求，则可以判定最后一天买完生煎之后，一定没有多余的生煎。

分析两种购买情况，第一种一天买两个，第二种则是一天买一个，由此可以分析得出，如果减去前一天剩余的生煎，今天仍需要购买的生煎数为偶数的话，就选择买第一种，这样一来今天买完后剩余的生煎数为0.

如果减去前一天为今天留下的生煎数后，今天仍需的生煎数为奇数，则需要买第二种，此时今天的生煎数满足了，但是为明天留下了一个生煎，即今天的剩余生煎数为1

通过循环走完n天，若n天后剩余的还有生煎，则失败，否则可以满足
代码

#include<iostream>
#include<string>
#include<cmath>
#include<map>
#include<queue>
using namespace std;

int N;
int* a;

int buy()
{//返回最后一天的生煎剩余量
	int flag = 0;//初始剩余量为0
	for (int i = 0; i < N; i++)
	{
		if ((a[i]-flag)% 2 == 0)
		{//当天还需要的生煎数量为偶数，买第一种
			flag = 0;
		}
		else//否则买第二种
		{
			flag = 1;
		}
	}

	return flag;
}

int main()
{
	cin >> N;
	a = new int[N];
	for (int i = 0; i < N; i++)
	{
		cin >> a[i];
	}
	
	int flag = buy();

	//根据最后一天买过之后生煎剩余数量进行判断
	if (flag == 0)
	{
		cout << "YES" << endl;
	}
	else
	{
		cout << "NO" << endl;
	}
}

C - 可怕的宇宙射线

众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！

宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂 次，每次分裂后会在分裂方向前进 个单位长度。
现在瑞神要带着他的小弟们挑战苟狗，但是瑞神不想让自己的智商降到普通本科生 那么菜的水平，所以瑞神来请求你帮他计算出共有多少个位置会被"降智打击。

输入
输入第一行包含一个正整数 ，表示宇宙射线会分裂 次
第二行包含n个正整数 ，第 个数 表示第 次分裂的宇宙射线会在它原方向上继续走多少个单位长度。
输出
输出一个数 ，表示有多少个位置会被降智打击
Sample Input

4
4 2 2 3

Sample Output

39

思路

因为在分裂过程中，不可避免地会有一些方格被多次经过，因此判断一个方格是否已经被降智打击很重要。可以采用二维数组from[x][y]来判断方格(x,y)是否已经被降智打击，四维数组s[x][y][number][flag]来判断(x,y)位置的方格在第number次分裂时flag方向是否延伸。

通过分析可以得到(左上<-上->右上)、(上<-右上->右)、(右上<-右->右下)、(右<-右下->下)、(右下<-下->左下)、(下<-左下->左)、(左下<-左->左上)，观察可看出每次分裂的方向都是其左右的两个方向，据此来设定dx、dy数组来方便坐标移动

通过递归实现，每次先判断分裂的次数是否小于N，小于继续分裂，否则终止分裂。

根据提供的当前行走方向，进行该方向相应单位长度的移动，然后再进行两个方向的分裂。直至分裂结束。

反思

在进行改题目的过程中，我第一次考虑的是先对当前的方向进行判断，然后通过if……else……语句来单独的进行判断下一次分裂的两个方向。后来经过指点，看出分裂的方向也可以构成一个环，由此来直接进行两个方向的分裂更为简便。

甚至于在考虑判断方格(x,y)是否被走过时，我起初想的是采用map，但考虑到使用map每次都要进行搜寻，不如二维数组直接访问来的迅速，因此放弃了使用map的想法。

同时，最开始我将起始点设置的为(0,0)，后来经过考虑，分裂的时候可能会出现负数的情况，此时会超出数组范围，出错，后改为接近数组中间的位置作为起始点。

初始数组开的过大，没有考虑到内存的问题，导致超出内存限制。后又对数组进行了相应的缩小。

代码

#include<iostream>
#include<string>
#include<cmath>
#include<map>
#include<queue>
#include<set>
using namespace std;

struct check
{
	int x;
	int y;
	check()
	{
		x = 0; 
		y = 0;
	}
	check(int x, int y)
	{
		this->x = x;
		this->y = y;
	}

	check& operator=(const check& rv)
	{
		x = rv.x;
		y = rv.y;
		return *this;
	}

	bool operator<(const check& rv)const
	{
		if (x != rv.x)
		{
			return x < rv.x;
		}
		else
		{
			return y < rv.y;
		}
	}
};



//int number = 0;
int N;//分裂次数
int* a;//记录第i次分裂射线走的单位长度
int result = 0;
//map<check, int> from;
int s[400][400][40][8] = { 0 };
int from[400][400] = { 0 };

//上，右上，右，右下，下，左下，左，左上
int dx[8] = { 0,1,1,1,0,-1,-1,-1 };
int dy[8] = { 1,1,0,-1,-1,-1,0,1 };



void fission(check ch,int flag,int number)//flag当前射线的方向
{
	if (number == N)
	{
		return;
	}

	
	if (s[ch.x][ch.y][number][flag] == 1)//如果该方格已经走过
	{
		return;
	}
	
	s[ch.x][ch.y][number][flag] = 1;

	for (int i = 0; i < a[number]; i++)//向flag方向延伸
	{
		ch.x += dx[flag];
		ch.y += dy[flag];
		//check temp(ch, _y);
		if (from[ch.x][ch.y] == 0)
		{
			result++;
			from[ch.x][ch.y] = 1;
		}
	}
	
	fission(ch, (flag + 1) % 8, number + 1);
	fission(ch, (flag + 7) % 8, number + 1);

}

int main()
{
	cin >> N;
	a = new int[N];
	for (int i = 0; i < N; i++)
	{
		cin >> a[i];
	}
	check ch(160, 160);
	fission(ch, 0, 0);
	cout << result << endl;
}