[蓝桥杯] 刷题记录（2020.3.22）

猜年龄

源地址
小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地说：“我们俩的年龄之积是年龄之和的6倍”。小明又补充说：“她们可不是双胞胎，年龄差肯定也不超过8岁啊。”

请你写出：小明的较小的妹妹的年龄。

输入

无

输出

无

样例输入

无

样例输出

无

代码

#include "iostream"
#include "cmath"
using namespace std;

int main()
{
    for (int i = 1; i < 100; i++)
    {
        for (int j = 1; j < 100; j++)
        {
            if (6 * (i + j) == i * j && fabs(i - j) < 9)
            {
                cout << i << " " << j << endl;
            }
        }
    }

    return 0;
}

切面条

源地址
一根高筋拉面，中间切一刀，可以得到2根面条。

如果先对折1次，中间切一刀，可以得到3根面条。

如果连续对折2次，中间切一刀，可以得到5根面条。

那么，连续对折10次，中间切一刀，会得到多少面条呢？

输入

无

输出

无

样例输入

无

样例输出

无

代码

2^n +1即可

神奇算式

源地址
由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。

比如：

210 x 6 = 1260

8 x 473 = 3784

27 x 81 = 2187

都符合要求。

如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。

输入

无

输出

无

样例输入

无

样例输出

无

代码

得到24种，因为结合律除以2结果便是12

#include "iostream"
#include "cstring"
using namespace std;

int main()
{
    int result = 0;
    for (int i = 1; i < 1000; i++)
    {
        for (int j = 1; j < 1000; j++)
        {
            int temp = i * j;
            int product = temp;
            if (temp > 9999 || temp < 1000)
            {
                continue;
            }
            else
            {
                int num[10];
                int count = 0;
                int a = i, b = j;
                bool find = true;
                memset(num, 0, sizeof(num));

                while (a)
                {
                    num[a % 10] = 1;
                    a /= 10;
                    count++;
                }
                while (b)
                {
                    num[b % 10] = 1;
                    b /= 10;
                    count++;
                }
                while (temp)
                {
                    if (num[temp % 10] == 0)
                    {
                        find = false;
                        break;
                    }
                    num[temp % 10] = 0;
                    temp /= 10;
                }
                if (find && count < 5)
                {
                    cout << i << "x" << j << "=" << product << endl;
                    result++;
                }
            }
        }
    }
    cout << result << endl;
    return 0;
}

扑克序列

源地址
A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。

要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。

请填写出所有符合要求的排列中，字典序最小的那个。

例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。

输入

无

输出

无

样例输入

无

样例输出

无

代码

#include "iostream"
#include "string"
#include "algorithm"
using namespace std;

int main()
{
    string str = "223344AA";
    do
    {
        if (str.rfind('A') - str.find('A') == 2)
        {
            if (str.rfind('2') - str.find('2') == 3)
            {
                if (str.rfind('3') - str.find('3') == 4)
                {
                    if (str.rfind('4') - str.find('4') == 5)
                    {
                        cout << str << endl;
                    }
                }
            }
        }
    } while (next_permutation(str.begin(), str.end()));

    return 0;
}

分糖果

源地址
有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏：

每个小朋友都把自己的糖果分一半给左手边的孩子。

一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。

反复进行这个游戏，直到所有小朋友的糖果数都相同为止。

你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。

输入

程序首先读入一个整数N(2 接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）#### 输出

样例输入

要求程序输出一个整数，表示老师需要补发的糖果数。

样例输出

3
2 2 4

代码

#include "iostream"
#include "string"
#include "algorithm"
using namespace std;

int main()
{
	int a[101];
	int n;
	int count = 0;

	bool stop = false;

	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}

	while (!stop)
	{
		bool all = true;
		int temp = a[0] / 2;
		a[0] /= 2;
		for (int i = 1; i < n; i++)
		{
			a[i - 1] += a[i] / 2;
			a[i] /= 2;
		}
		a[n - 1] += temp;
		for (int i = 0; i < n; i++)
		{
			if (a[i] % 2 == 1)
			{
				a[i]++;
				count++;
			}
		}
		for (int i = 1; i < n; i++)
		{
			if (a[i - 1] != a[i])
			{
				all = false;
			}
		}
		if (all)
		{
			stop = true;
		}
	}

	cout << count;

	return 0;
}

兰顿蚂蚁

源地址
兰顿蚂蚁，是于1986年，由克里斯·兰顿提出来的，属于细胞自动机的一种。

平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。

蚂蚁的头部朝向为：上下左右其中一方。

蚂蚁的移动规则十分简单：

若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；

若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。

规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。

蚂蚁的路线是很难事先预测的。

你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。

输入

输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。
接下来是 m 行数据。
每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。
接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从左到右增长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k 表示蚂蚁走的步数。

输出

输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。

样例输入

5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 3 L 5

样例输出

1 3

代码

#include "iostream"
#include "string"
#include "algorithm"
using namespace std;

int main()
{
	int a[101][101];
	int n, m, pos;
	int x, y, count;
	char dir[4] = {'U', 'R', 'D', 'L'};
	char temp;
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> a[i][j];
		}
	}
	cin >> x >> y >> temp >> count;
	for (int i = 0; i < 4; i++)
	{
		if (temp == dir[i])
		{
			pos = i;
		}
	}

	for (int i = 0; i < count; i++)
	{
		if (a[x][y])
		{
			a[x][y] = 0;
			pos++;
			if (pos == 4)
			{
				pos = 0;
			}
		}
		else
		{
			a[x][y] = 1;
			pos--;
			if (pos == -1)
			{
				pos = 3;
			}
		}
		switch (pos)
		{
		case 0:
			x--;
			break;
		case 1:
			y++;
			break;
		case 2:
			x++;
			break;
		case 3:
			y--;
			break;
		}
	}
	cout << x << " " << y;

	return 0;
}

蚂蚁感冒

源地址
长100厘米的细长直杆子上有n只蚂蚁。它们的头有的朝左，有的朝右。

每只蚂蚁都只能沿着杆子向前爬，速度是1厘米/秒。

当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

这些蚂蚁中，有1只蚂蚁感冒了。并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

输入

第一行输入一个整数n (1 < n < 50), 表示蚂蚁的总数。
接着的一行是n个用空格分开的整数 Xi (-100 < Xi < 100), Xi的绝对值，表示蚂蚁离开杆子左边端点的距离。正值表示头朝右，负值表示头朝左，数据中不会出现0值，也不会出现两只蚂蚁占用同一位置。其中，第一个数据代表的蚂蚁感冒了。

输出

要求输出1个整数，表示最后感冒蚂蚁的数目。

样例输入

10
50 3 4 6 -8 12 -7 11 -60 -65

样例输出

8

代码

1. 两只蚂蚁相遇就掉头，相当于什么都没发生
2. 朝左的蚂蚁感冒，朝右的蚂蚁也一定会感冒，反之亦然
3. 数据默认第一只蚂蚁朝右

#include "iostream"
#include "cstring"
#include "cmath"
using namespace std;

int main()
{
	int a[51];
	int n;
	int count = 0;

	cin >> n;

	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}
	for (int i = 1; i < n; i++)
	{
		// 朝右但是在第一只蚂蚁左边
		// （因为会有向左的蚂蚁感染并传染给它）
		if (abs(a[i]) < abs(a[0]) && a[i] > 0)
		{
			count++;
		}
		// 朝左但是在第一只蚂蚁右边
		else if (abs(a[i]) > abs(a[0]) && a[i] < 0)
		{
			count++;
		}
	}
	// 加上第一只蚂蚁
	cout << count + 1;

	return 0;
}

地宫取宝

源地址
X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。

地宫的入口在左上角，出口在右下角。

小明被带到地宫的入口，国王要求他只能向右或向下行走。

走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。

请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。

输入

输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)
接下来有 n 行数据，每行有 m 个整数 Ci (0<=Ci<=12)代表这个格子上的宝物的价值

输出

要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对 1000000007 取模的结果。

样例输入

2 3 2
1 2 3
2 1 5

样例输出

14

代码

估计是超时了

#include "iostream"
#include "cstring"
#include "cmath"
using namespace std;
int value[51][51];
int n, m, k;
long long ans;
void dfs(int x, int y, int count, int maxValue)
{
	if (x >= n || y >= m || count > k)
	{
		return;
	}
	if (x == n - 1 && y == m - 1)
	{
		if ((count == k) || (count == k - 1 && value[x][y] > maxValue))
		{
			ans++;
			ans %= 1000000007;
			return;
		}
	}
	// 拿
	if (value[x][y] > maxValue)
	{
		dfs(x + 1, y, count + 1, value[x][y]);
		dfs(x, y + 1, count + 1, value[x][y]);
	}
	// 不拿
	dfs(x + 1, y, count, maxValue);
	dfs(x, y + 1, count, maxValue);
}
int main()
{
	cin >> n >> m >> k;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> value[i][j];
		}
	}
	dfs(0, 0, 0, -1);
	cout << ans;

	return 0;
}