洛谷入门综合训练2

P1426 小鱼会有危险吗

P1426 总结

这个题目代码有个细节很关键，我一开始就将求和写在了开头，后来没有通过[3,4]这个测试数据，原因是一开始就应该进行计算，因此还是应该将求和写在后面更好一些。

题目描述
有一次，小鱼要从A处沿直线往右边游，小鱼第一秒可以游7米，从第二秒开始每秒游的距离只有前一秒的98%。有个极其邪恶的猎人在距离A处右边s米的地方，安装了一个隐蔽的探测器，探测器左右x米之内是探测范围。一旦小鱼进入探测器的范围，探测器就会在这一秒结束时把信号传递给那个猎人，猎人在一秒后就要对探测器范围内的水域进行抓捕，这时如果小鱼还在这范围内就危险了。也就是说小鱼一旦进入探测器范围，如果能在下1秒的时间内马上游出探测器的范围，还是安全的。现在给出s和x的数据，请你判断小鱼会不会有危险？如果有危险输出’y’，没有危险输出’n’。

//感谢黄小U饮品完善题意

输入格式
一行内输入两个实数，用空格分隔，表示s和x。均不大于100

输出格式
一行内输出’y’或者’n’表示小鱼是否会有危险。

输入输出样例
输入 #1复制
14 1
输出 #1复制
n

#include<iostream>
using namespace std;
int main() {
	float s, x;
	cin >> s >> x;
	float l = s - x;
	float r = s + x;
	float percent = 0.98;
	float firststep = 7;
	float sum = 0;
	while (1) {
		sum += firststep;//这个写在了开头
		if (sum > r) {
			cout << "n";
			break;
		}
		else if (sum >= l&&sum < r) {
			float ldist = sum - l;
			float rdist = r - sum;
			float ltime = ldist / firststep;
			float rtime = rdist / (firststep*percent);
			float sumtime = ltime + rtime;
			if (sumtime >= 1)cout << "y";
			else cout << "n";
			break;
		}
		else {
			firststep = firststep*percent;
		}
	}
	return 0;
}

#include<iostream>
using namespace std;
int main() {
	float s, x;
	cin >> s >> x;
	float l = s - x;
	float r = s + x;
	float percent = 0.98;
	float firststep = 7;
	float sum = 0;
	while (1) {
		if (sum > r) {
			cout << "n";
			break;
		}
		else if (sum >= l&&sum < r) {
			float ldist = sum - l;
			float rdist = r - sum;
			float ltime = ldist / firststep;
			float rtime = rdist / (firststep*percent);
			float sumtime = ltime + rtime;
			if (sumtime >= 1)cout << "y";
			else cout << "n";
			break;
		}
		else {
			sum += firststep;
			firststep = firststep*percent;
		}
	}
	return 0;
}

P1464 Function

P1464 总结

这一题真是让我开了眼界，知道了什么叫记忆化搜索，把递归的复杂性降到了最低。尤其是简单粗暴的对于3个未知数的递归程序，直接开辟一个三维数组。

但是这里面这个递归程序也很特殊，在一开始对于小于0的情况进行了剔除，也就是有了一个下限；另外对于大于20的数也有一个规范返回w（20，20，20）；也相当于有了一个上界。经过这两个条件筛选后，基本上只剩下了0-20的数了，因此对于这20个数进行记忆化搜索就可以了。

题目描述
对于一个递归函数w(a,b,c)w(a,b,c)

如果a \le 0a≤0 or b \le 0b≤0 or c \le 0c≤0就返回值11.
如果a>20a>20 or b>20b>20 or c>20c>20就返回w(20,20,20)w(20,20,20)
如果a<ba<b并且b<cb<c 就返回w(a,b,c-1)+w(a,b-1,c-1)-w(a,b-1,c)w(a,b,c−1)+w(a,b−1,c−1)−w(a,b−1,c)
其它的情况就返回w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1)w(a−1,b,c)+w(a−1,b−1,c)+w(a−1,b,c−1)−w(a−1,b−1,c−1)
这是个简单的递归函数，但实现起来可能会有些问题。当a,b,ca,b,c均为15时，调用的次数将非常的多。你要想个办法才行.

/* absi2011 : 比如 w(30,-1,0)w(30,−1,0)既满足条件1又满足条件2

这种时候我们就按最上面的条件来算

所以答案为1

*/

输入格式
会有若干行。

并以-1,-1,-1−1,−1,−1结束。

保证输入的数在[-9223372036854775808,9223372036854775807][−9223372036854775808,9223372036854775807]之间，并且是整数。

输出格式
输出若干行，每一行格式：

w(a, b, c) = ans

注意空格。

输入输出样例
输入 #1复制
1 1 1
2 2 2
-1 -1 -1
输出 #1复制
w(1, 1, 1) = 2
w(2, 2, 2) = 4

#include<iostream>
using namespace std;
int dp[30][30][30];
int dfs(int a, int b, int c) {
	if (a <= 0 ||b <= 0 || c <= 0)
		return 1;
	if (a > 20 || b > 20 || c > 20) //上面这两个条件完全限制了a,b,c的范围，abc的有效范围必须是1-20;大于20的必定会回退到20
		return dfs(20, 20, 20);
	if (dp[a][b][c] != 0)
		return dp[a][b][c];//记忆化搜索，避免重复计算
	if (a < b&&b < c)
		dp[a][b][c] = dfs(a, b, c - 1) + dfs(a, b - 1, c - 1) - dfs(a, b - 1, c);
	else
		dp[a][b][c] = dfs(a - 1, b, c) + dfs(a - 1, b - 1, c) + dfs(a - 1, b, c - 1) - dfs(a - 1, b - 1, c - 1);
	return dp[a][b][c];
}

int main() {
	int num1, num2, num3;
	memset(dp, 0, sizeof(dp));
	while (cin >> num1 >> num2 >> num3) {
		if (num1 == -1 && num2 == -1 && num3 == -1)break;
		else
			cout << "w(a, b, c) = "<<dfs(num1, num2, num3)<<endl;
	}

	return 0;
}

P1307 数字反转

这一题主要还是复习了一下前面的关于头部尾部去0的操作以及对数字进行取第一位字符的操作。

题目描述
给定一个整数，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例2）。

输入格式
一个整数 NN

输出格式
一个整数，表示反转后的新数。

输入输出样例
输入 #1复制
123
输出 #1复制
321
输入 #2复制
-380
输出 #2复制
-83
说明/提示
数据范围

-1,000,000,000≤N≤1,000,000,000−1,000,000,000≤N≤1,000,000,000。

noip2011普及组第一题

#include<iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	bool IsNagtive = 0;
	if (n < 0) {
		n = -n;
		IsNagtive = 1;
	}
	int ReverseN = 0;
	while (n/10!=0&&n%10==0) {
		n = n / 10;
	}
	while (n) {
		ReverseN = ReverseN * 10;
		ReverseN += n % 10;
		n = n / 10;
	}
	if (IsNagtive) {
		cout << "-" << ReverseN;
	}
	else {
		cout << ReverseN;
	}
	return 0;
}

P1022 计算器的改良

总结

在做的时候我把对象分成了三种类，分别是符号±，字母a,x，以及常量1，2，3。在计算的时候主要就是这几个量之间的转换。

这个题目主要还是类似于模拟，然后使用的思想跟之前的栈，还有翻转字符等等很类似，都是等到下一个符号的时候进行结算，然后根据情况会增加一些特别的判断量，因此会有一些特别的逻辑变量在里面。

题目背景
NCLNCL是一家专门从事计算器改良与升级的实验室，最近该实验室收到了某公司所委托的一个任务：需要在该公司某型号的计算器上加上解一元一次方程的功能。实验室将这个任务交给了一个刚进入的新手ZL先生。

题目描述
为了很好的完成这个任务，ZLZL先生首先研究了一些一元一次方程的实例：

4+3x=84+3x=8

6a-5+1=2-2a6a−5+1=2−2a

-5+12y=0−5+12y=0

ZLZL先生被主管告之，在计算器上键入的一个一元一次方程中，只包含整数、小写字母及+、-、=这三个数学符号（当然，符号“-”既可作减号，也可作负号）。方程中并没有括号，也没有除号，方程中的字母表示未知数。

你可假设对键入的方程的正确性的判断是由另一个程序员在做，或者说可认为键入的一元一次方程均为合法的，且有唯一实数解。

输入格式
一个一元一次方程。

输出格式
解方程的结果(精确至小数点后三位)。

输入输出样例
输入 #1复制
6a-5+1=2-2a
输出 #1复制
a=0.750

#include<iostream>
#include<string>
using namespace std;
int main() {
	string eq;
	cin >> eq;
	double cof, constval;
	cof = 0;
	constval = 0;
	int Positive, IsNum;
	Positive = 1;//默认为整数
	IsNum = 1;
	int OnLeft = 1;
	int tempval=0;
	int HasValue = 0;
	char Unknown;
	for (auto ch : eq) {
		if (ch == '+') {
			if (IsNum == 1) { constval += tempval*Positive*(-OnLeft); }
			else {
				cof += tempval*Positive*OnLeft;
			}
			HasValue = 0;
			Positive = 1;
			tempval = 0;
			IsNum = 1;
		}
		if (ch == '-') {
			if (IsNum == 1) { constval += tempval*Positive*(-OnLeft); }
			else {
				cof += tempval*Positive*OnLeft;
			}
			HasValue = 0;
			Positive = -1;
			tempval = 0;
			IsNum = 1;
		}
		if (ch == '=') {
			if (IsNum == 1) { constval += tempval*Positive*(-OnLeft); }
			else {
				cof += tempval*Positive*OnLeft;
			}
			HasValue = 0;
			OnLeft = -1;
			Positive = 1;
			tempval = 0;
			IsNum = 1;
		}
		if (ch >= '0'&&ch <= '9') {
			HasValue = 1;
			tempval = tempval * 10;//进位
			tempval += ch - '0';
		}
		if (ch >= 'a'&&ch <= 'z') {
			if (HasValue == 0)tempval = 1;
			IsNum = 0;
			Unknown = ch;
		}
	}
	if (IsNum == 1) { constval += tempval*Positive*(-OnLeft); }
	else {
		cof += tempval*Positive*OnLeft;
	}
	if (!(constval / cof))printf("%c=0.000",Unknown);
	else printf("%c=%.3f", Unknown, constval / cof);
	return 0;
}