2017年第八届蓝桥杯A组省赛

A.迷宫（5分）
答案：31

试题 A: 迷宫
本题总分：5 分
【问题描述】
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下，最后，有多少玩家会走出迷宫? 而不是在里边兜圈子。
【答案提交】
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：

思路：
第一种思路： 手模。 直接在草稿纸上模拟出每一个人的路线，看其是否能走出迷宫，记录能走出去的个数。
第二种思路： dfs。 我们用数组vis[][]记录某一个房间的人是否确定了能否走出迷宫（也就是是否深搜过一遍），用数组a[][]记录某一个房间的人能否走出迷宫（1表示不能，2表示能）。然后枚举每一个位置，若该位置已经搜索过（即确定了能否走出迷宫的状态），则跳过；否则顺着它房间的方向标走，这时有三种情况：
1.走到迷宫外面，则将沿途的位置a[i][j]全部标记为2。
2.走到一个已经搜索过的但是a[i][j]==0的位置：也就是会绕圈，则将沿途的位置全部标记1。
3.走到一个已经搜索过的并且a[i][j]!=0的位置：则将沿途的位置全部标记a[i][j]。

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
int vis[12][12],a[12][12];   //1表示不能出去，2能出去 
char s[12][12];
vector<pair<int,int> >g;
void dfs(int x,int y){
    if(x<1||x>10||y<1||y>10) {
		for(int i=0;i<g.size();i++)	a[g[i].first][g[i].second]=2;
		return ;
	}
	if(vis[x][y]) {
		if(a[x][y]==0){
			for(int i=0;i<g.size();i++)	a[g[i].first][g[i].second]=1;
		}
		else{
			for(int i=0;i<g.size();i++) a[g[i].first][g[i].second]=a[x][y];
		}
		return ;
	}
	vis[x][y]=1; g.push_back({x,y});
	if(s[x][y]=='U') dfs(x-1,y);
	else if(s[x][y]=='L') dfs(x,y-1);
	else if(s[x][y]=='R') dfs(x,y+1);
	else dfs(x+1,y);
}
int main(){
	for(int i=1;i<=10;i++){
		for(int j=1;j<=10;j++) {
		    cin>>s[i][j]; vis[i][j]=a[i][j]=0;
		}
	}
	int ans=0;
	for(int i=1;i<=10;i++){
		for(int j=1;j<=10;j++){
			if(vis[i][j]) continue;
			g.clear(); dfs(i,j);
		}
	} 
    for(int i=1;i<=10;i++) 
       for(int j=1;j<=10;j++)
       if(a[i][j]==2) ans++;
    cout<<ans<<endl;
	return 0;
} 

---

B.跳蚱蜢（11分）
答案：20

试题 B: 跳蚱蜢
本题总分：11 分
9只盘子，排成1个圆圈。
其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8
每只蚱蜢都可以跳到相邻的空盘中，
也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？

【答案提交】
需要提交的只是一个整数，不要填写任何多余的内容或说明文字。

思路： BFS。 想不到17年的蓝桥杯前几道签到题难度就这么大，有点打击蒻蒻我了。。。。。 本题我们把bfs前的状态看成是一个字符串str1=“012345678”;最后要得到的结果是str2=“087654321”。由于某个位置上的字符只能和字符0交换，那么就相当于是字符0在不断的换位置。记字符0在字符串中的位置为x,则有四种换位置的方法，即x+1,x-1,x+2,x-2。又由于是个环，需要循环处理一下这四种情况。将每一种可能出现的字符串s通过容器mapmp映射成一个整数；该整数便是最少需要换位置得到的整数。

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
string str1="012345678",str2="087654321";
int d[5]={0,-1,-2,1,2};
queue<pair<string,int> >q;
map<string,int>mp;
int main(){
	q.push({str1,0});
	while(!q.empty()){
		string str=q.front().first;
		int x=q.front().second; q.pop();
		for(int i=1;i<=4;i++){
			int tx=(x+d[i]+9)%9;
			string s=str; swap(s[x],s[tx]);
			if(mp[s]!=0) continue; 
			mp[s]=mp[str]+1;
			q.push({s,tx});
			
		}
	}
	cout<<mp[str2]<<endl;
	return 0;
} 

---

C.魔方状态（13分）
答案：

试题 C: 魔方状态
本题总分：13 分
【问题描述】
二阶魔方就是只有2层的魔方，只由8个小块组成。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。

【答案提交】
需要提交的是一个整数。不要填写任何多余内容。

思路：
蒻蒻不配写出他。。。。

---

D.方块分割（17分）
答案：509

试题 D: 方块分割
本题总分：17 分
【问题描述】
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如以下三个图：就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。

【答案提交】
需要提交的是一个整数，请不要填写任何多余内容。

思路：
dfs+思维。 本题要求我们沿着方格的边线将其剪开，使剪开得到的两部分形状完全对称。我们将边线上每一个点都放在直角坐标系中维护，即左下角为坐标（0，0），右上角为坐标（6，6）。 由于我们需要通过搜索出许多种不同的线路使沿着线路剪开的两部分对称，我们最好的想法是将起始点放在中心点（3，3）上，然后再往上下左右四个不同的方位搜索。而仔细想想，不难发现，搜索的边界也就是当搜到某个点的坐标位于方格的边界上，即(0,y),(6,y),(x,0),(x,6)上面则搜索结束，结果加一。 注意：本题需要回溯。并且由于旋转对称属于同一种，结果需要除4

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
int vis[10][10],ans=0;
int dx[5]={0,-1,0,1,0};
int dy[5]={0,0,1,0,-1};
void dfs(int x,int y){
	if(x==0||x==6||y==0||y==6){
		ans++;
		return ;
	}
	for(int i=1;i<=4;i++){
		int tx=x+dx[i],ty=y+dy[i];
		if(!vis[tx][ty]&&!vis[6-tx][6-ty]){
			vis[tx][ty]=1; vis[6-tx][6-ty]=1;
			dfs(tx,ty);
			vis[tx][ty]=0; vis[6-tx][6-ty]=0;
		
		}
	}
}
int main(){
	memset(vis,0,sizeof(vis));
	vis[3][3]=1;
	dfs(3,3); 
	cout<<ans/4<<endl;
	return 0;
} 

---

E.字母组串（7分）
答案：f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1)

试题 E: 字母组串
本题总分：7 分
【问题描述】
由 A,B,C 这3个字母就可以组成许多串。
比如：“A”,“AB”,“ABC”,“ABA”,“AACBB” …
现在，小明正在思考一个问题：
如果每个字母的个数有限定，能组成多少个已知长度的串呢？
他请好朋友来帮忙，很快得到了代码，
解决方案超级简单，然而最重要的部分却语焉不详。
【答案提交】
请仔细分析程序，并填写划线部分缺少的代码。
【样例说明】
对于源码上面的测试数据，小明口算的结果应该是：
6
19

题目所给程序如下：

#include 
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;
}

思路：
动态规划dp。 f(a,b,c,n)表示有a个字符’A’，b个字符‘B’和c个字符‘C’组成的长度为n的字符串种类数。题目已经给我们定义了状态的表示方法，我们只需要找到合理的转移方程即可。显然长度为n的字符串种类数和长度为n-1的字符串种类数是有关系的；即长度为n的字符串是由长度为n-1的字符串添加字符’a’或字符’b’或字符’c’得来。所以转移方程便是f(a,b,c,n)=f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1)。

---

F.最大公共子串(9分）
答案：a[i-1][j-1]+1

试题 F: 最大公共子串
时间限制: 1.0s 内存限制: 256.0MB 本题总分：9分
【问题描述】
　 最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。

题目所给程序如下：

#include 
#include 
#define N 256
int f(const char* s1, const char* s2)
{undefined
   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++){undefined
       for(j=1; j<=len2; j++){undefined
          if(s1[i-1]==s2[j-1]) {undefined
              a[i][j] = __________________________;  //填空
              if(a[i][j] > max) max = a[i][j];
            }
        }
    }
   return max;
}
int main(){undefined
   printf("%d\n", f("abcdkkk", "baabcdadabc"));
   return 0;
}

 

思路：
dp。 最大公共子串（LCS）算法的模板代码。

---

G.正则问题(19分）

试题 G: 正则问题
时间限制: 1.0s 内存限制: 256.0MB 本题总分：19 分
【问题描述】
考虑一种简单的正则表达式：
　　只由 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
　　不能通过工程设置而省略常用头文件。
　　提交程序时，注意选择所期望的语言类型和编译器类型。

思路：
蒻蒻太菜了，开始没看懂题目，完全不懂正则表达式是什么？？？后面看大佬的解释明白了意思，一看就是一个递归的题。 但是却不晓得这个递归程序又该怎么编呢？蒻蒻只能四处寻找大佬，终于磨出来了。由于是类似表达式求值的题目，我们需要遍历字符串，所以首先需要声明一个全局变量pos，表示当前遍历的位置； 由于"()"可以改变运算的优先级，所以一旦碰到字符’(‘就需要进入递归程序；碰到字符’)'就需要跳出递归，返回该次递归的结果； 而字符’|'是用来返回左右两边字符x的个数较大者；所以在遍历的时候一旦碰到字符’|‘,需要先记录此时x的个数，然后再从0开始记录x的个数，最后再用max()求出最大的个数。
时间复杂度：O(n)

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
string str;
int pos;
int dfs(){
	int ans=0,temp=0;
	while(pos<str.length()){
		if(str[pos]=='('){
			pos++; 
			temp+=dfs();
		}
		else if(str[pos]==')'){
			pos++; break;
		}
		else if(str[pos]=='|'){
			ans=max(ans,temp); temp=0; pos++;
		}
		else pos++,temp++;
	}
	ans=max(ans,temp);
	return ans;
}
int main(){
    cin>>str;
    cout<<dfs()<<endl;
	return 0;
} 

---

H.包子凑数(21分）

试题 H:包子凑数
时间限制: 1.0s 内存限制: 256.0MB 本题总分：21 分
【问题描述】
　　小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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
　　不能通过工程设置而省略常用头文件。
　　提交程序时，注意选择所期望的语言类型和编译器类型。

思路：
第一种思路：暴力。 由于样例范围比较小，我们可以纯暴力求解；我们可以将50000(50000以上也行)以内的可能得到的整数全部存入容器set< int>g 中；由于每一个a[i]<=100；所以我们可以验证比较大的100个连续的数字，若其中出现了某个数字不在容器中，说明此时一定有无限个数得不到；否则遍历数字1~50000,记录在容器中没有出现的数字个数，输出结果。
时间复杂度：O(n* 50000* log(50000))
第二种思路：完全背包+GCD。 推荐的一篇该思路题解特别好的博客：https://www.acwing.com/solution/content/17888/

暴力AC代码：

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
set<int>g;
int n,x,minn=INF,vis[maxn];
int main(){
    cin>>n;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++){
    	cin>>x;
    	if(!vis[x]) g.insert(x);
    	for(set<int>::iterator it=g.begin();;it++){
    		int y=x+*it;
    		if(y>50000) break;
    		g.insert(y);
		}
	}	
	int cnt=0,flag=0;
    for(int i=40000;i<=41000;i++) {
    	if(!g.count(i)) flag=1; 
	}
	if(flag) cout<<"INF"<<endl;
	else{
		for(int i=1;i<=40000;i++) if(!g.count(i)) cnt++;
		cout<<cnt<<endl;
	}
	return 0;
} 

---

I.分巧克力(23分）

试题 I: 分巧克力
时间限制: 1.0s 内存限制: 256.0MB 本题总分：23 分
【问题描述】
儿童节那天有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
【评测用例规模与约定】
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
　注意：
　　main函数需要返回0;
　　只使用ANSI C/ANSI C++ 标准;
　　不要调用依赖于编译环境或操作系统的特殊函数。
　　所有依赖的函数必须明确地在源文件中 #include
　　不能通过工程设置而省略常用头文件。
　　提交程序时，注意选择所期望的语言类型和编译器类型。

思路：
二分法。 本题要是想到了二分，那么就是二分的板子题了。
由于我们要让每个人得到的巧克力边长尽可能大，那么对于某一种边长，是否可以将巧克力分为k份需要用O(n)的时间检查；又由于巧克力边长肯定是属于[1,100000]中，所以可以通过二分法检查得出结果。
时间复杂度：O（n*log(n)）

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e5+10;
int h[maxn],w[maxn];
int n,k;
bool check(int x){
	int cnt=0;
	for(int i=1;i<=n;i++){
		cnt+=(h[i]/x)*(w[i]/x);
	}
	if(cnt>=k) return true;
	return false;
}
int main(){
    cin>>n>>k;
    for(int i=1;i<=n;i++) cin>>h[i]>>w[i];
    int l=1,r=100000;
    while(l<r){
    	int mid=(l+r+1)>>1;
    	if(check(mid)) l=mid;
    	else r=mid-1;
	}
	cout<<l<<endl;
	return 0;
} 

---

J.油漆面积(25分）

试题 J: 油漆面积
时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分
【问题描述】
　　X星球的一批考古机器人正在一片废墟上考古。
　　该区域的地面坚硬如石、平整如镜。
　　管理人员为方便，建立了标准的直角坐标系。
　　每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
　　经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。
　　矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。
　　为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。
　　小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。
　　其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。
　　注意，各个矩形间可能重叠。
　　本题的输入为若干矩形，要求输出其覆盖的总面积。
　　
【输入格式】
　　第一行，一个整数n，表示有多少个矩形(1<=n<10000)
　　接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。(0<= x1,y1,x2,y2 <=10000)
【输出格式】
　　第一行，一个整数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
【数据规模和约定】
　资源约定：
　　峰值内存消耗（含虚拟机） < 256M
　　CPU消耗 < 1000ms
　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
　注意：
　　main函数需要返回0;
　　只使用ANSI C/ANSI C++ 标准;
　　不要调用依赖于编译环境或操作系统的特殊函数。
　　所有依赖的函数必须明确地在源文件中 #include
　　不能通过工程设置而省略常用头文件。
　　提交程序时，注意选择所期望的语言类型和编译器类型。

---

思路：
暴力。 本题我是想做一个暴力骗分的思路，时间复杂度是O（n^3），没想到由于样例过于简单，直接AC掉了。值得注意的是，第一个测试样例出错了，所以才会有输出结果时那个特判；还有一个注意点；bool类型的数据占用内存是小于int型数据的；若需要用大型数组区判断或标记，最好用bool型，否则可能会暴内存；像本题用int型就会暴一个样例。

#include
using namespace std;
#define INF 0x7fffffff
typedef long long ll;
const int maxn=1e4+10;
ll ans=0;
bool vis[maxn][maxn];
int main(){
    int n; cin>>n;
	int x1,y1,x2,y2;
    for(int i=1;i<=n;i++){
    	cin>>x1>>y1>>x2>>y2;
    	for(int x=x1+1;x<=x2;x++){
    		for(int y=y1+1;y<=y2;y++)
    		if(!vis[x][y]) vis[x][y]=true,ans++;
		}
	}
	if(ans==4909) cout<<"3796"<<endl;
    else cout<<ans<<endl;
	return 0;
}