蓝桥杯第八届省赛A组c/c++

A. 迷宫
X星球的一处迷宫游乐场建在某个小山坡上。它是由10x10相互连通的小房间组成的。

房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。

X星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！

开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。

迷宫地图如下：

UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下，最后，有多少玩家会走出迷宫?
而不是在里边兜圈子。

请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。

如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：

答案：31
代码：

#include<iostream>
#include<cstring>
using namespace std;
char g[11][11];
int v[11][11];
int res; 
bool  dfs(int x,int y)
{
	if(x < 0 || x > 9 || y < 0 || y > 9)
	{
		return true;
	}
	if(v[x][y])
	return false;
	v[x][y] = 1;
	if(g[x][y] == 'U') return dfs(x - 1,y);
	if(g[x][y] == 'R') return dfs(x,y + 1);
	if(g[x][y] == 'D') return dfs(x + 1,y);
	if(g[x][y] == 'L') return dfs(x,y - 1);
	return false;
	
}
int main()
{
	for(int i = 0;i < 10;i++)
	for(int j = 0;j < 10;j++)
	cin >> g[i][j];
	for(int i = 0;i < 10;i++)
	for(int j = 0;j < 10;j++)
	{
		memset(v,0,sizeof(v));
		if(dfs(i,j))
		{
			res++;
		}
	}
	cout << res;
	return 0;
}

B. 跳蚱蜢
如图 所示：

有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。我们把这些蚱蜢顺时针编号为 1~8

每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。

请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？

注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。

答案 ：20

代码：

#include<iostream>
#include<string>
#include<queue>
#include<set>
using namespace std;
string end = "012345678";//目标字符串
int d[4] = {-2,-1,1,2};//位置数组，以0的位置为中心前或后的1-2格可以跳到0上
int main()
{
	queue<string> q;
	set<string> us;
	q.push("087654321");
	us.insert("087654321");//set判断重复
	int step = -1;//步数，去除开始状态-1
	while(!q.empty())
	{
		int size = q.size();
		step ++;
		for(int i = 0;i < size;i++)
		{
			string s = q.front();
			q.pop();
			int pos = s.find('0');//寻找0的位置
			for(int i = 0;i < 4;i++)//枚举四个位置
			{
				int nextpos = (pos + d[i] + 9) % 9;//是为了位置出现复数的情况，下一个状态
				swap(s[pos],s[nextpos]);//交换
				if(!us.count(s))
				{
					us.insert(s);
					q.push(s);
				}
				swap(s[pos],s[nextpos]);//恢复
			}
		}
	}
	cout << step;
	return 0;
}

C. 魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。如图所示。

小明很淘气，他只喜欢3种颜色，所以把家里的二阶魔方重新涂了颜色，如下：

前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色

请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。

如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。

请提交表示状态数的整数，不要填写任何多余内容或说明文字。

答案：229878

D. 方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。

如图就是可行的分割法。

试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。

请提交该整数，不要填写任何多余的内容或说明文字。

分析
如图，我们可以从(3,3)这个点遍历，标记所以走过的地方st[x][y]和它的对称点st[6 - x][6 - y]，如果到了边界，那么一定是一个合法方案。

答案：509

代码

#include <iostream>
#include <cstdio>

using namespace std;

bool st[7][7];
int ans;
int dx[] = {1, 0, 0, -1}, dy[] = {0, 1, -1, 0};

void dfs(int x, int y)
{
	if (x == 0 || x == 6 || y == 0 || y == 6)
	{
		ans++;
		return;
	}
	for (int i = 0; i < 4; i++)
	{
		int tx = x + dx[i], ty = y + dy[i];
		if (st[tx][ty]) continue;
		st[tx][ty] = true;
		st[6 - tx][6 - ty] = true;
		dfs(tx, ty);
		st[tx][ty] = false;
		st[6 - tx][6 - ty] = false;
	}
}

int main()
{
	st[3][3] = true;
	dfs(3, 3);
	cout << ans / 4 << endl;
	return 0;
}

E. 字母组串
由 A,B,C 这3个字母就可以组成许多串。
比如：“A”,“AB”,“ABC”,“ABA”,“AACBB” …

现在，小明正在思考一个问题：
如果每个字母的个数有限定，能组成多少个已知长度的串呢？

他请好朋友来帮忙，很快得到了代码，
解决方案超级简单，然而最重要的部分却语焉不详。

请仔细分析源码，填写划线部分缺少的内容。

#include <stdio.h>

// a个A，b个B，c个C 字母，能组成多少个不同的长度为n的串。
int f(int a, int b, int c, int n)
{
	if(a<0 || b<0 || c<0) return 0;
	if(n==0) return 1; 
	
	return ______________________________________ ;  // 填空
}

int main()
{
	printf("%d\n", f(1,1,1,2));
	printf("%d\n", f(1,2,3,3));
	return 0;
}

对于上面的测试数据，小明口算的结果应该是：
6
19

注意：只填写划线部分缺少的代码，不要提交任何多余内容或说明性文字。

分析
答案: f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1)

F. 最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

#include <stdio.h>
#include <string.h>

#define N 256
int f(const char* s1, const char* s2)
{
	int a[N][N];
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int i,j;
	
	memset(a,0,sizeof(int)*N*N);
	int max = 0;
	for(i=1; i<=len1; i++){
		for(j=1; j<=len2; j++){
			if(s1[i-1]==s2[j-1]) {
				a[i][j] = __________________________;  //填空
				if(a[i][j] > max) max = a[i][j];
			}
		}
	}
	
	return max;
}

int main()
{
	printf("%d\n", f("abcdkkk", "baabcdadabc"));
	return 0;
}

注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

答案：a[i - 1][j - 1] + 1

H. 包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。

输入

第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)

输出

一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

例如，
输入：

2
4
5
程序应该输出：

6
再例如，
输入：

2
4
6
程序应该输出：

INF

代码：

#include<iostream>
#include<string>
const int N = 101;
int n;
int a[N],res;
int dp[2 * N];
using namespace std;
int gcd(int a,int b)
{
	return b == 0 ? a : gcd(b,a % b);
}
int main()
{
	cin >> n;
	for(int i = 0;i < n;i++)
	cin >> a[i];
	int d = a[0];
	for(int i = 1;i < n;i++)
	d = gcd(d,a[i]); 
	if(d != 1)
	{
		cout << "INF";
		return 0;
	}
	dp[0] = 1;
	for(int i = 0;i < n;i++)
	{
		for(int j = 0;j + a[i] < 2 * N;j++)
		{
			if(dp[j]) dp[j + a[i]] = 1;
		}
	}
	for(int i = 0;i < 2 * N;i++)
	if(!dp[i]) res ++;
	cout << res;
	return 0;
}

I. 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。

为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：

1. 形状是正方形，边长是整数
2. 大小相同

例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。

当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？

输入

第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。

输出

输出切出的正方形巧克力最大可能的边长。

样例输入：

2 10
6 5
5 6
样例输出：

2

#include<iostream>
#include<string>
using namespace std;
const int N = 100001;
int n,k;
int h[N],w[N];
bool check(int x)
{
	int sum = 0;
	for(int i = 0;i < n;i++)
	sum += (h[i] / x) * (w[i] / x);
	return sum >= k;
}

int main()
{
	cin >> n >> k;
	for(int i = 0;i < n;i++)
	cin >> h[i] >> w[i];
	int l = 1,r = N;
	while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
	cout << l;
} 

J. 油漆面积
X星球的一批考古机器人正在一片废墟上考古。该区域的地面坚硬如石、平整如镜。管理人员为方便，建立了标准的直角坐标系。每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。

矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。注意，各个矩形间可能重叠。

本题的输入为若干矩形，要求输出其覆盖的总面积。

输入格式：
第一行，一个整数n，表示有多少个矩形(1<=n<10000)
接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)

输出格式：
一行一个整数，表示矩形覆盖的总面积。

例如，
输入：

3
1 5 10 10
3 1 20 20
2 7 15 17
程序应该输出：

340
再例如，
输入：

3
5 2 10 6
2 7 12 10
8 1 15 15
程序应该输出：

128

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int n;
struct Segment{
	int x, y1, y2;
	int k;
	bool operator < (Segment t)
	{
		return x < t.x;
	}
}seg[N * 2];
struct Node{
	int l, r;
	int cnt, len;
}tr[N * 4];

void pushup(int u)
{
	if (tr[u].cnt > 0) tr[u].len = tr[u].r - tr[u].l + 1;
	else if (tr[u].l == tr[u].r) tr[u].len = 0;
	else tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
}

void build(int u, int l, int r)
{
	tr[u] = {l, r};
	if (l == r) return;
	int mid = l + r >> 1;
	build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
	
}

void modify(int u, int l, int r, int k)
{
	if (tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].cnt += k;
		pushup(u);
	}
	else
	{
		int mid = tr[u].l + tr[u].r >> 1;
		if (l <= mid) modify(u << 1, l, r, k);
		if (r > mid) modify(u << 1 | 1, l, r, k);
		pushup(u);
	}
}

int main()
{
	scanf("%d", &n);
	int m = 0;
	for (int i = 0; i < n; i++)
	{
		int x1, y1, x2, y2;
		scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
		seg[m++] = {x1, y1, y2, 1};
		seg[m++] = {x2, y1, y2, -1};
	}
	
	sort(seg, seg + m);
	
	build(1, 0, 10000);
	
	int res = 0;
	for (int i = 0; i < m; i++)
	{
		if (i > 0) res += tr[1].len * (seg[i].x - seg[i - 1].x);
		modify(1, seg[i].y1, seg[i].y2 - 1, seg[i].k);
	}
	
	printf("%d\n", res);
	
	return 0;
}