7-1 打字（C++）

题目描述：

如果你仍然再用二指禅打字，那我建议你重新学习打字，这样你打字会更快，感觉更舒适和愉快。

有很多网站教授正确的打字。下图描述了基本原理: 用同一手指按压颜色相同的键。黄色键需要用小指按压，蓝色的用无名指，绿色的用中指，红色的用食指。

另外，左手按键盘的左侧（从左侧的5、T、G、B键开始）右手按压右侧（从右侧的键6、Y、H、N开始）。拇指负责空格键。

图片描述的键盘是美式键盘。

现在，给出一段长度为 $len(1\le len\le 50)$ 的字符串，请你计算如果正确打出这个字符串，每个手指敲击键盘的次数。

输入格式:

输入为一行，一个由大写字母、数字和特殊符号组成的字符串（不包括空格，不需要管图片中未显示的按键）。

输出格式:

输出8行，表示左手小指、无名指、中指、食指以及右手食指、中指、无名指、小指敲击键盘的次数。

输入样例1:

AON=BOO; 

输出样例1:

1
0
0
1
1
0
3
2

输入样例2:

PRINT'NY'[NASLA] 

输出样例2:

2
1
0
2
4
1
1
5

解题思路：

char fingers[8][10]列出每个手指对应的字符

对于读入的每个字符，遍历匹配即可

实现代码如下

#include <iostream>
#include <string>
using namespace std;

char fingers[8][10] = {
	{ '`', '1', 'Q', 'A', 'Z', '\0' },
	{ '2', 'W', 'S', 'X', '\0' },
	{ '3', 'E', 'D', 'C', '\0' },
	{ '4', '5', 'R', 'T', 'F', 'G', 'V', 'B', '\0' },
	{ '6', '7', 'Y', 'U', 'H', 'J', 'N', 'M', '\0' },
	{ '8', 'I', 'K', ',', '\0' },
	{ '9', 'O', 'L', '.', '\0' },
	{ '0', 'P', ';', '/', '-', '[', '\'', '=', ']', '\0' }
};
size_t press_num[8] = { 0 };

int main() {
	bool is_find;
	string str;
	cin >> str;
	for (size_t i = 0; i < str.size(); i++) {
		is_find = false;
		for (size_t j = 0; j < 8; j++) {
			size_t k = 0;
			while (fingers[j][k]) {
				if (str[i] == fingers[j][k]) {
					press_num[j]++;
					is_find = true;
				}
				if (is_find) break;
				k++;
			}
			if (is_find) break;
		}
	}

	for (size_t i = 0; i < 8; i++) cout << press_num[i] << endl;
	return 0;
}

7-2 分香肠（C++，最大公约数）

题目描述：

有 N 根完全相同的香肠， 现在要平均分给 M 个客人。 问最少需要切几刀才能将其平均分给客人（不能多个香肠一起切）。

输入格式:

两个整数 N(1≤N≤105) 和 M(1≤M≤105)

输出格式:

一个整数，表示要切的刀数

输入样例:

在这里给出一组输入。例如：

2 6

输出样例:

在这里给出相应的输出。例如：

4

解题思路：

先N %= M，分出去一部分香肠

然后举个例子，如果说现在剩下$6$根香肠要分给$10$个客人

直接$10-1=9$是会有$1$刀切空

同理，如果剩下9根香肠分给15个客人

直接$15-1=14$会有$2$刀切空

关于“切空”的原因，模拟一下就会发现是因为周期性，分组就可以解决这个问题

拿第一个例子说，比例是$\frac{6}{10}$，可以通分变成$\frac{3}{5}$，意思就是分为2组，每组有3根香肠和5个客人

cout << (5 - 1) * 2 << endl即可

实现代码如下

#include <iostream>
using namespace std;

size_t great_common_division(size_t s_1, size_t s_2) {
	if (s_2 == 0) return 0;

	size_t temp;
	while (s_2 != 0) {
		temp = s_1 % s_2;
		s_1 = s_2;
		s_2 = temp;
	}
	return s_1;
}

int main() {
	size_t n, m;
	cin >> n >> m;
	n = n % m;
	if (n == 0)
		cout << 0;
	else{
		size_t gcd = great_common_division(m, n);
		n /= gcd;
		m /= gcd;
		cout << (m - 1) * gcd;
	}
	return 0;
}

7-3 凌乱的yyy / 线段覆盖(C++，贪心)

题目背景

快 noip 了，yyy 很紧张！

题目描述

现在各大 oj 上有 $n$ 个比赛，每个比赛的开始、结束的时间点是知道的。

yyy 认为，参加越多的比赛，noip 就能考的越好（假的）。

所以，他想知道他最多能参加几个比赛。

由于 yyy 是蒟蒻，如果要参加一个比赛必须善始善终，而且不能同时参加 $2$ 个及以上的比赛。

输入格式

第一行是一个整数 $n$ ，接下来 $n$ 行每行是 $2$ 个整数 $a_i,b_i$ ( $a_i<b_i$ )，表示比赛开始、结束的时间。

输出格式

一个整数最多参加的比赛数目。

样例 #1

样例输入 #1

3
0 2
2 4
1 3

样例输出 #1

2

提示

对于 $20\%$ 的数据， $n\le 10$。

对于 $50\%$ 的数据， $n\le 10^3$。

对于 $70\%$ 的数据， $n\le 10^5$。

对于 $100\%$ 的数据， $1\le n\le 10^6$ ， $0\le a_i<b_i\le 10^6$。

解题思路：

尽量选择结束时间更早的比赛，因为可以留出更多的时间

实现代码如下

#include <iostream>
#include <algorithm>
using namespace std;

const int max_n = int(1e6);

struct competition {
public:
	int start;
	int end;
};

competition competitions[max_n];
competition* end_first[max_n] = { NULL };

int main() {
	int current_t = 0, n, sum = 0;
	cin >> n;
	for (int i = 0; i < n; i++) {//读入比赛起止时间
		cin >> competitions[i].start >> competitions[i].end;
		end_first[i] = &competitions[i];
	}

	sort(end_first, end_first + n, [](competition* e_f_1, competition* e_f_2) {//依照结束时间排序
		return e_f_1->end < e_f_2->end;
		});

	for (int i = 0; i < n; i++) {//搜索最大参赛量
		if (current_t <= end_first[i]->start) {
			sum++;
			current_t = end_first[i]->end;
		}
	}
	cout << sum << endl;
	return 0;
}

7-4 外星密码（C++，分治，递归）

题目描述

有了防护伞，并不能完全避免 2012 的灾难。地球防卫小队决定去求助外星种族的帮助。经过很长时间的努力，小队终于收到了外星生命的回信。但是外星人发过来的却是一串密码。只有解开密码，才能知道外星人给的准确回复。解开密码的第一道工序就是解压缩密码，外星人对于连续的若干个相同的子串 $\text{X}$ 会压缩为 $\text{[DX]}$ 的形式（$D$ 是一个整数且 $1\le D\le 99$），比如说字符串 $\text{CBCBCBCB}$ 就压缩为 $\text{[4CB]}$ 或者$\text{[2[2CB]]}$，类似于后面这种压缩之后再压缩的称为二重压缩。如果是 $\text{[2[2[2CB]]]}$ 则是三重的。现在我们给你外星人发送的密码，请你对其进行解压缩。

输入格式

输入一行，一个字符串，表示外星人发送的密码。

输出格式

输出一行，一个字符串，表示解压缩后的结果。

样例 #1

样例输入 #1

AC[3FUN]

样例输出 #1

ACFUNFUNFUN

提示

【数据范围】

对于 $50\%$ 的数据：解压后的字符串长度在 $1000$ 以内，最多只有三重压缩。

对于 $100\%$ 的数据：解压后的字符串长度在 $20000$ 以内，最多只有十重压缩。保证只包含数字、大写字母、[ 和 ]。

解题思路：

题目的输入是一个被压缩的字符串（之后称其为str），由被压缩部分（之后称之为sub_str）和未被压缩部分两部分组成

每个sub_str也可以看作由num（代表重复次数）和str（代表重复部分）两部分组成

可以看出，需要采用递归算法解压缩

实现函数read_string()，功能：读入str，返回解压之后的字符串

实现思路：逐个字符读入后连接到str尾部，如果读到[，那么通过num * read_string()得到sub_str，最后读到文件尾EOF后返回str，直接输出即可

实现代码如下

#include <iostream>
using namespace std;

string read_string() {
	int num;
	string str, sub_str;
	char c;
	while (cin >> c) {
		if (c == '[') {
			cin >> num;
			sub_str = read_string();
			while (num--)str += sub_str;
		}
		else {
			if (c == ']') {
				return str;
			}
			str += c;
		}
	}
	return str;
}

int main() {
	cout << read_string();
	return 0;
}

7-5 [NOIP2012 提高组] 国王游戏（C++，贪心，高精度）

题目描述

恰逢 H 国国庆，国王邀请 $n$ 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这 $n$ 位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。

国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。

输入格式

第一行包含一个整数 $n$，表示大臣的人数。

第二行包含两个整数 $a$ 和 $b$，之间用一个空格隔开，分别表示国王左手和右手上的整数。

接下来 $n$ 行，每行包含两个整数 $a$ 和 $b$，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。

输出格式

一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。

样例 #1

样例输入 #1

3 
1 1 
2 3 
7 4 
4 6

样例输出 #1

2

提示

【输入输出样例说明】

按 $1$、$2$、$3$ 这样排列队伍，获得奖赏最多的大臣所获得金币数为 $2$；

按 $1$、$3$、$2$ 这样排列队伍，获得奖赏最多的大臣所获得金币数为 $2$；

按 $2$、$1$、$3$ 这样排列队伍，获得奖赏最多的大臣所获得金币数为 $2$；

按$ 2$、$3$、$1 $这样排列队伍，获得奖赏最多的大臣所获得金币数为 $9$；

按 $3$、$1$、$2 $这样排列队伍，获得奖赏最多的大臣所获得金币数为 $2$；

按$ 3$、$2$、$1$ 这样排列队伍，获得奖赏最多的大臣所获得金币数为 $9$。

因此，奖赏最多的大臣最少获得 $2$ 个金币，答案输出 $2$。

【数据范围】

对于 $20\%$ 的数据，有 $1\le n\le 10,0<a,b<8$；

对于 $40\%$ 的数据，有$ 1≤ n≤20,0 < a,b < 8$；

对于 $60\%$ 的数据，有 $1\le n\le 100$；

对于 $60\%$ 的数据，保证答案不超过 $10^9$；

对于 $100\%$ 的数据，有 $1\le n\le 1,000,0<a,b<10000$。

解题思路：

先不考虑如何使最大值尽可能的小，只针对某一位固定的大臣

为了使这位大臣所获得的金币数最少，我们希望他前面所有人左手上的数乘积尽可能的小，同时这位大臣右手上的数尽可能的大

要使乘积尽可能的小，需要使乘数尽可能的少、使排队的人左手上的数尽可能的小

所以现在有三个目的：该大臣前面的人数尽可能的少，前面的人左手上的数尽可能的小，他右手上的数尽可能的大

以上三条就是减少一位大臣获得奖赏的所有方法

然后我们来考虑如何使最大值尽可能的小

对于第一条，只需要让最大值站在国王后面就可以了，但这显然不合理

对于第二条，前面的人左手上的数尽可能的小，可以说就是后面的人左手上的数尽可能的大

也就是说左手数越大的大臣，我们偏向于让他站在后面

对于第三条，我们偏向于让右手数越大的大臣站在越后面

那么是不是左右手乘积越大站在越后面就行了呢？接下来进行证明

现假设有n位大臣，编号分别为$p_1,p_2,\dots ,p_n$，其中获得奖赏最多的为$p_k(1\le k\le n)$

要使max减少，需要进行位置交换，假设将$p_i,p_j(1\le i\le k\le j\le n,i\ne j)$进行交换可以使max减少

可以看到，对于所有$p_i$之前和$p_j$之后的大臣，其获得的金币数不受影响

设左手数数组、右手数数组分别为left[n + 1],right[n + 1]

接下来分类讨论三种情况

（1）i != k && j != k

由于$p_k$的右手数不会改变，前方人数不变，max减少一定是因为第二条

可以看到，$p_{i+1}$~$p_{j-1}$所获得的奖赏均减少

同时由于$p_j$的右手数不变，且因为第一条，所以$p_j$获得金币数减少

要使max减少，只需要使$p_i\le max$或$p_k$即可

可以推导出$new{p}_i=\frac{lef{t}_1\ast \cdots \ast lef{t}_{j-1}\ast \frac{lef{t}_j}{lef{t}_i}}{righ{t}_j\ast \frac{righ{t}_i}{righ{t}_j}}=old{p}_j\ast \frac{lef{t}_j\ast righ{t}_j}{lef{t}_i\ast righ{t}_i}$（注：这个式子除了$i<j$之外没有任何限制）

若有$p_i$左右手乘积更大，则有$new{p}_i<old{p}_j\le max$

（2）i == k && j != k

由于$p_k$的右手数不会改变，前方大臣左手数乘积增大，显然不可能使max减小

（3）i != k && j == k

显然max减少是因为第一条，有$righ{t}_k>righ{t}_i$

由（1）式子可得，如果$p_i$的左右手乘积更大，$new{p}_i<old{p}_k\le max$

若$lef{t}_k\le lef{t}_i$，则$p_{i+1}$~$p_{k-1}$所获得的的奖赏均减少，故max减少了

若$lef{t}_k>lef{t}_i$，显然$p_k$的左右手乘积更大，不能和$p_i$交换

至此，证明完毕

接下来是代码的实现，注意可能会出现$1000^{9999}$故需要使用高精度

#include <iostream>
#include <algorithm>
#include <iomanip>
//#include <fstream>//Debug
using namespace std;

const size_t bits = 10;//1e10进制
const int64_t mod_num = 10000000000;//1e10

struct person {
	int left;
	int right;
};

person queue[1001];
int64_t num[2][10000] = { {1},{1} };//10000 * bits位
int64_t max_num[10000] = { 0 };//2^63 - 1 = 9 223 372 036 854 775 807
int max_len = 0;
//int max_i;//Debug

int main() {
	//ifstream ifs("C:\\Users\\dell\\Downloads\\P1080_9.in", ios::in);//Debug
	int n, highest = 0;
	cin >> n;
	//ifs >> n;//Debug
	for (int i = 0; i <= n; i++)
		cin >> queue[i].left >> queue[i].right;
		//ifs >> queue[i].left >> queue[i].right;//Debug
	//ifs.close();//Debug
	sort(queue + 1, queue + n + 1, [](person p_1, person p_2) {
		return p_1.left * p_1.right < p_2.left * p_2.right;
		});

	for (int i = 1; i <= n; i++) {
		//if (i == 1000) system("pause");//Debug
		num[(i + 1) % 2][0] = int64_t(queue[i - 1].left) * num[i % 2][0];
		int j = 1;
		while (j <= highest + 1)
		{
			num[(i + 1) % 2][j] = int64_t(queue[i - 1].left) * num[i % 2][j];
			num[(i + 1) % 2][j] += num[(i + 1) % 2][j - 1] / mod_num;
			num[(i + 1) % 2][j - 1] %= mod_num;
			j++;
		}

		while (j > 0 && num[(i + 1) % 2][j] == 0) j--;
		highest = j;
		int z = j;
		int64_t upper = 0, lower = 0;
		while (z >= 0) {
			upper = (num[(i + 1) % 2][z] + lower) / int64_t(queue[i].right);
			lower = (num[(i + 1) % 2][z] + lower) % int64_t(queue[i].right) * mod_num;
			if (upper > max_num[z]) {
				max_len = j;
				//max_i = i;//Debug
				lower = 0;
				while (j >= 0) {
					upper = (num[(i + 1) % 2][j] + lower) / int64_t(queue[i].right);
					lower = (num[(i + 1) % 2][j] + lower) % int64_t(queue[i].right) * mod_num;
					max_num[j] = upper;
					j--;
				}
				break;
			}
			else if (upper == max_num[z]) {
				z--;
				continue;
			}
			else break;
		}
	}

	//cout << max_i << endl;//Debug
	cout << max_num[max_len];
	while (--max_len >= 0) cout << setiosflags(ios::right) << setfill('0') << setw(bits) << max_num[max_len];
}

我的高精度稍微改了一下，不想看的这段可以直接跳过

改动的第一个地方就是把10进制改成了1e10进制

这样好处就是可以把大臣手上的数看成一位（因为一定小于1e10），并减少循环次数

需要做出的改变就是模数由10变为1e10，在输出的时候要格式化一下

改动的第二个地方就是使用两个高精度数字进行高精度乘法（也就是%2的意义，i每改变奇偶性一次，乘积和乘数交换一次）

这样好处就是节约了空间