蓝桥杯第八届 省赛 c语言A组

第一题

标题:迷宫

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

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

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

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

迷宫地图如下:
------------
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
------------

请你计算一下,最后,有多少玩家会走出迷宫? 
而不是在里边兜圈子。

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

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

【思路】

dfs,模拟走路,深度遍历每一条路,设置走出迷宫的条件,每走一步标记该点已经走过(剪枝),避免重复走。

答案:31

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

char map[10][10];
int a[10][10];


bool dfs(int i, int j) {
    if (i < 0 || i > 9 || j < 0 || j > 9)
        return true;
    else if (a[i][j] == 1)
        return false;
    else {
        a[i][j] = 1;
        if (map[i][j] == 'L')
            return dfs(i, j - 1);
        else if (map[i][j] == 'R')
            return dfs(i, j + 1);
        else if (map[i][j] == 'U')
            return dfs(i - 1, j);
        else 
            return dfs(i + 1, j);   
    }
}

int main(){
    
    string str = "UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR";
    int k = 0;
    int rec = 0;

    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            map[i][j] = str[k];
            k++;
        }
    }
        
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            memset(a, 0, sizeof(a));
            if (dfs(i, j))
                rec ++;
        }
    }

    cout << rec << endl;

    return 0;
}

 

第二题

标题:跳蚱蜢

如图 所示:


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

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

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

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

【思路】

设置排列为“123456789”,蚂蚱代表9,依照题意,最终的排列结果应该为"876543219"

再来分析题目,蚂蚱跳相当于盘子的位置改变,所以盘子每次改变位置的情况有四种{-1,1,-2,2}

显然要模拟排列情况,而且由于要求求出最小的步数,想到可以利用广度遍历思想解题。

每次头元素出队,找到头元素(一个排列)的9的位置(蚂蚱的位置),让他分别从4个方向跳,新的排列存储到队列中,如果目标队列出现,则输出相应的结果。

这里运用一个set集合记录元素的序号。具体处理细节查看代码。

答案:20

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int size = 1000000000;
bool visit[size];
int temp[] = {1, -1, 2, -2}, a[10];
int start = 123456789, last = 876543219;

int get_num(int *a) {
    int sum = 0;
    for (int i = 0; i < 9; i++) {
        sum *= 10;
        sum += a[i];
    }
    return sum;
}

int main(){    
    memset(visit, 0, sizeof(visit));
    queue<int> q;
    queue<int> b;
    q.push(start);
    visit[start] = 1;
    b.push(0);
    while (1) {
        int a_front = q.front(), b_front = b.front();
        int c = 8, now;
        while (a_front > 0) {
            if (a_front % 10 == 9) now = c; //记录数字9在当前数组的位置
            a[c--] = a_front % 10;
            a_front /= 10;
        }
        for (int i = 0; i < 4; i++) {
            swap(a[now], a[(now+9+temp[i])%9]);
            int d = get_num(a);
            if (!visit[d]) {
                visit[d] = 1;
                if (d == last) {
                    cout << b_front + 1 << endl;
                    return 0;
                }
                q.push(d);
                b.push(b_front+1);
            }
           swap(a[now], a[(now+9+temp[i])%9]);
        }    
        q.pop();
        b.pop();
    }
}

 

第五题 

标题:字母组串

由 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

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

【思路】

由代码可知必定用到了递归。当前位置的总数等于用了a的总数加上用了b的总数加上用了c的总数。

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

 

第七题

描述:正则问题

考虑一种简单的正则表达式:
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。  

例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是: xxxxxx,长度是6。

输入
----
一个由x()|组成的正则表达式。输入长度不超过100,保证合法。  

输出
----
这个正则表达式能接受的最长字符串的长度。  

例如,
输入:
((xx|xxx)x|(x|xx))xx  

程序应该输出:
6  

资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

注意:
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时,注意选择所期望的语言类型和编译器类型。

【思路】

设置一个栈,遍历字符串,当遍历到')'以外的元素时,元素压栈

对遍历到字符')'的处理:

1.元素一直出栈直到对应的'('出栈;

2.元素如果不是'|',则计算这一段连续的串中一共有多少个x;

3.元素如果是'|',则把之前计算到的x的数目压入到一个数组中,重新计算x的数目;

4.当最后遍历到'('时,数组中普通情况下会存在数字,每个数字代表一段连续的x的个数,选出最大的数字,压入栈中,在这里我用字符串处理,即将这个数字强制转换为字符压入栈中,因为输入的字符串长度不超出100,所以可以这样处理。这也解释了为什么第二种情况我没说"元素如果是x",因为元素可能是100以内的字符,但这不影响我们计算x的个数。

#include <bits/stdc++.h>
using namespace std;
const int num = 100;

int max_num(int *a, int n) {
	int max = -1;
	for (int i = 0; i < n; i++) {
		if (max < a[i])
			max = a[i];
	}
	return max;
}

int main() {
	stack<char> st;
	string s;
	int a[num], t, rec, max;
	char c;
	cin >> s;
	for (int i = 0; i < s.size(); i++) {
		if (s[i] == '(' || s[i] == '|' || s[i] == 'x')
			st.push(s[i]);
		else {
			c = st.top();
			t = 0;
			rec = 0;
			while (c != '(') {
				if (c != '|') {
					if (c == 'x')
						t ++;
					else
						t += (int)c;
				}
				else {
					a[rec++] = t;
					t = 0;
				}
				st.pop();
				c = st.top();
			}
			st.pop();
			a[rec++] = t;
			max = max_num(a, rec);
			st.push((char)max);
			memset(a, 0, sizeof(a));
			rec = 0;
		}
	}
	rec = 0;
	t = 0;
	while (!st.empty()) {
		c = st.top();
		if (c != '|') {
			if (c == 'x')
				t ++;
			else
				t += (int)c;
		}
		else {
			a[rec++] = t;
			t = 0;
		}
		st.pop();
	}
	a[rec++] = t;
	max = max_num(a, rec);
	cout << max << endl;
	return 0;
}

 

第八题

标题:包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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

样例解释:
对于样例1,凑不出的数目包括:1, 2, 3, 6, 7, 11。  
对于样例2,所有奇数都凑不出来,所以有无限多个。  

资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

注意:
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时,注意选择所期望的语言类型和编译器类型。

【思路】

此题解不能完全正确。

首先要知道给出的数据中没有互质的数,则有无数种情况不能被组合。

下面代码只是模拟了在一个范围内能够被组合的数,输出这个范围内不能被组合的数的个数。

此思路是网上看到的,自己之前写了一个暴力破解某个数是否能被组合,而当然这个数足够大电脑就宕机了。。。

一个很大的困惑是在有限种情况下,那个能被组合出来的最大数值是多少,可能以后会补充。

#include <bits/stdc++.h>
using namespace std;
const int num = 100000;
int n;
int a[100];
int dp[num];
bool flag;

bool gcd(int x, int y) {
	while (y != 0) {
		int rec = x;
		x = y;
		y = rec % y;
	}
	if (x == 1)
		return true;
	else
		return false;
}

int main() {
	cin >> n;
	int m;
	for (int i = 0; i < n; i++)
		cin >> a[i];
	flag = false;
	for (int i = 0; i < n-1; i++) {
		for (int j = i+1; j < n; j++) {
			if (gcd(a[i], a[j])) {
				flag = true;
				break;
			}
		}
		if (flag == true)
			break;
	}
	if (flag = false)
		cout << "INF" << endl;
	else {
		memset(dp, 0, sizeof(dp));
		for (int i = 0; i < n; i++) {
			dp[a[i]] = 1;
			for (int j = 0; j+a[i] < num; j++) {
				if(dp[j])
					dp[j+a[i]] = 1;
			}
		}
		int k = 0;
		for (int i = 1; i < num; i++) {
			if (!dp[i])
				k++;
		}
		cout << k << endl;
	}
	return 0;
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值