第八届蓝桥杯大赛个人赛省赛题目答案

第八届省赛题目

1

• 题目

  标题：迷宫
  
  X星球的一处迷宫游乐场建在某个小山坡上。
  它是由10x10相互连通的小房间组成的。
  
  房间的地板上写着一个很大的字母。
  我们假设玩家是面朝上坡的方向站立，则：
  L表示走到左边的房间，
  R表示走到右边的房间，
  U表示走到上坡方向的房间，
  D表示走到下坡方向的房间。
  
  X星球的居民有点懒，不愿意费力思考。
  他们更喜欢玩运气类的游戏。这个游戏也是如此！
  
  开始的时候，直升机把100名玩家放入一个个小房间内。
  玩家一定要按照地上的字母移动。
  
  迷宫地图如下：
  ------------
  UDDLUULRUL
  UURLLLRRRU
  RRUURLDLRD
  RUDDDDUUUU
  URUDLLRRUU
  DURLRLDLRL
  ULLURLLRDU
  RDLULLRDDD
  UUDDUDUDLL
  ULRDLUURRR
  ------------
  
  请你计算一下，最后，有多少玩家会走出迷宫? 
  而不是在里边兜圈子。
  

• 代码

  #include 
  #include 
  /* run this program using the console pauser or add your own getch, system("pause") or input loop */
  
  char dir[11][11] = {"UDDLUULRUL",
                      "UURLLLRRRU",
                      "RRUURLDLRD",
                      "RUDDDDUUUU",
                      "URUDLLRRUU",
                      "DURLRLDLRL",
                      "ULLURLLRDU",
                      "RDLULLRDDD",
                      "UUDDUDUDLL",
                      "ULRDLUURRR"};
  
  int sum = 0;
  bool vis[10][10];
  
  void canOut(int i, int j)
  {
      for(int i=0;i<10;i++)
          for(int j=0;j<10;j++)
              vis[i][j] = false;
      while( true )
      {
          if( i>9 || j>9 || i<0 || j<0 )
          {
              sum++;
              break;
          }
          if( vis[i][j] )
              break;
          vis[i][j] = true;
          switch( dir[i][j] )
          {
              case 'U' : i--; break;
              case 'L' : j--; break;
              case 'D' : i++; break;
              case 'R' : j++; break;
              default : break;
          }
      }
  
  }
  int main(int argc, char *argv[]) {
      for(int i=0;i<10;i++)
      {
          for(int j=0;j<10;j++)
          {
              canOut(i,j);
          }
      }
      printf("count that can be out : %d\n", sum);
  
      return 0;
  }
  

2

• 题目

  标题：跳蚱蜢
  
  如图 p1.png 所示： 
  有9只盘子，排成1个圆圈。
  其中8只盘子内装着8只蚱蜢，有一个是空盘。
  我们把这些蚱蜢顺时针编号为 1~8
  
  每只蚱蜢都可以跳到相邻的空盘中，
  也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
  
  请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
  并且保持空盘的位置不变（也就是1-8换位，2-7换位,...），至少要经过多少次跳跃？
  
  注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。
  

• 参考链接：http://blog.csdn.net/JiaweiLee2012/article/details/79040145

• 思路：因为是求最小步数，所以可以采用BFS来求解，在每一次列举出4种可能的情况，然后存储当前的步数，再根据当前的状态进行下一步的动作。可以采用队列去进行存储，状态与到达该状态所需要的步骤在不同队列的相同位置，当找到目标状态的时候，退出BFS的搜索。在这里我对原文链接中的代码进行处理，在每次向队列中添加状态的时候，首先判断该状态是否已经被访问过，如果已经被访问过，则不将其放入队列中，可以减少算法运行的时间。具体是在extend函数中

• 答案

  #include 
  #include 
  #include 
  using namespace std;
  int dir[4] = {-2, -1, 1, 2};
  int state[9];
  int zp; // 空盘位置
  
  bool visited[876543211];
  
  queue q;
  queue cnt; 
  
  // 解码 
  void setState(int num)
  {
      for(int i=8; i>=0; i--)
      {
          if( num%10 == 0 )
              zp = i;
          state[i] = num%10;
          num /= 10;
      }
  }
  
  // 编码 
  int getVal()
  {
      int num = 0;
      for(int i=0;i<9;i++)
      {
          num = num*10 + state[i];
      }
      return num;
  } 
  
  bool extend()
  {
      int num = q.front();
      if( num == 87654321 )
          return false;
      if( visited[num] )
          return true;
      visited[num] = true;
      setState( num );
      for(int i=0;i<4;i++)
      {
          state[zp] = state[(zp+dir[i]+9)%9 ];
          state[(zp+dir[i]+9)%9 ] = 0;
          if( !visited[getVal()] )
          {
              q.push( getVal() );
              cnt.push( cnt.front()+1 );
          }
          else
          {
              printf("%d\n", getVal());
          } 
          setState( num );
      }
      return true;
  }
  
  int main()
  {
      setState(12345678);
      q.push( 12345678 );
      cnt.push(0);
      while( extend() && !cnt.empty() )
      {
          q.pop();
          cnt.pop();
      }
      cout << cnt.front() << endl;
      return 0;
  }
  

3

• 题目

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

• 这一题不会求解，在网上找的答案结果也互不相同，目前没写。

4

• 题目

  标题：方格分割
  
  6x6的方格，沿着格子 的边线剪开成两部分。
  要求这两部分的形状完全相同。
  
  如图：p1.png, p2.png, p3.png 就是可行的分割法。
  
  试计算：
  包括这3种分法在内，一共有多少种不同的分割方法。
  注意：旋转对称的属于同一种分割法。
  
  请提交该整数，不要填写任何多余的内容或说明文字。
  

• 分析：这道题可以使用dfs求解，将方格分割成2个对称且连接的部分，相当于我们需要找到一个连接线，即找到连接线条之间的点。6X6的方格中有7X7个顶点，我们只需要从这7个顶点中找到符合要求的点进行划分即可，中心点肯定需要在其中，因此我们从中心点开始，然后依次向4个方向进行扩张；由于对称性，每次需要按照对称的方式扩张2个点。最后考虑到旋转相同的问题，需要将找到的结果除以4，即得到最终的结果。

• 代码

  #include 
  #include 
  using namespace std;
  
  bool book[7][7];
  int dir[4][2] = {-1,0,1,0,0,-1,0,1};
  int N = 6;
  int sum = 0;
  
  void dfs( int r, int c )
  {
      if( r==0 || r==N || c==0 || c==N )
      {
          sum++;
          return;
      }
      int tmpr,tmpc;
      for(int i=0;i<4;i++)
      {
          tmpr = r + dir[i][0];
          tmpc = c + dir[i][1];
          if( tmpr>N || tmpr<0 || tmpc>N || tmpc<0 )
              continue;
          if( !book[tmpr][tmpc] )
          {
              book[tmpr][tmpc] = true;
              book[N-tmpr][N-tmpc] = true;
  
              dfs( tmpr, tmpc );
  
              book[tmpr][tmpc] = false;
              book[N-tmpr][N-tmpc] = false;
          }
      }
  }
  
  int main()
  {
      book[N/2][N/2] = true;
      dfs( N/2, N/2 );
      printf("%d\n", sum/4);
      return 0;
  } 
  

5

• 题目

  标题：字母组串
  
  由 A,B,C 这3个字母就可以组成许多串。
  比如："A","AB","ABC","ABA","AACBB" ....
  
  现在，小明正在思考一个问题：
  如果每个字母的个数有限定，能组成多少个已知长度的串呢？
  
  他请好朋友来帮忙，很快得到了代码，
  解决方案超级简单，然而最重要的部分却语焉不详。
  
  请仔细分析源码，填写划线部分缺少的内容。
  

• 代码

  #include 
  
  // 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 f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1) ;  // 填空
  }
  
  int main()
  {
      printf("%d\n", f(1,1,1,2));
      printf("%d\n", f(1,2,3,3));
      return 0;
  }
  

6

• 题目

  标题：最大公共子串
  
  最大公共子串长度问题就是：
  求两个串的所有子串中能够匹配上的最大长度是多少。
  
  比如："abcdkkk" 和 "baabcdadabc"，
  可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
  
  下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
  
  请分析该解法的思路，并补全划线部分缺失的代码。
  

• 代码

  #include 
  #include 
  
  #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] = a[i-1][j-1] + 1;  //填空
                  if(a[i][j] > max) max = a[i][j];
              }
          }
      }
  
      return max;
  }
  
  int main()
  {
      printf("%d\n", f("abcdkkk", "baabcdadabc"));
      return 0;
  }
  

7

• 题目

  描述：正则问题
  
  考虑一种简单的正则表达式：
  只由 x ( ) | 组成的正则表达式。
  小明想求出这个正则表达式能接受的最长字符串的长度。  
  
  例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。
  
  输入
  ----
  一个由x()|组成的正则表达式。输入长度不超过100，保证合法。  
  
  输出
  ----
  这个正则表达式能接受的最长字符串的长度。  
  
  例如，
  输入：
  ((xx|xxx)x|(x|xx))xx  
  
  程序应该输出：
  6  
  

• 参考链接：http://blog.csdn.net/weixin_38960774/article/details/79413463

• 思路：采用DFS的方法，遇到(就开始新的搜索，遇到)则停止搜索并通过比较，找出这个括号里的最大值；如果遇到|，则需要记录之前的长度，用于在之后)的比较。

• 代码

  #include 
  #include 
  
  char s[100] = "((xx|xxx)x|(x|xx))xx";
  int result;
  int pos, len; 
  
  int max(int a, int b)
  {
      return a >= b ? a : b;
  }
  
  int dfs( )
  {
      int num = 0, ret = 0;
      while( pos < len )
      {
          if( s[pos] == '(' )
          {
              pos++;
              num = num + dfs( );
          }
          else if( s[pos] == ')' )
          {
              pos++;
              break;
          }
          else if( s[pos] == '|' ) //保存 
          {
              pos++;
              ret = max(num, ret);
              num = 0;
          }
          else
          {
              pos++;
              num++;
          }
      }
      ret = max( ret, num );
      return ret;
  }
  
  int main()
  {
      len = strlen( s );
      pos = 0;
      result = dfs( );
  
      printf("%d\n", result);
  
      return 0;
  }
  

8

• 题目

  标题：包子凑数
  
  小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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，所有奇数都凑不出来，所以有无限多个。  
  

• 思路：首先要确定结果是否为INF，如果所有数的最大公约数不为1，则结果为INF；然后再使用动态规划的方法，建立数组，判断他们是否可达，最后再找出所有没有到达的数的下标即可。

• 代码

  #include 
  #include 
  
  int N;
  int num[101];
  bool map[10001];
  
  int gcd( int a, int b )
  {
      int tmp;
      if( a < b )
      {
          tmp = a;
          a = b;
          b = tmp;
      }
      while( a%b != 0 )
      {
          tmp = b;
          b = a%b;
          a = b;
      }
      return b;
  }
  
  int get_gcd()
  {
      if( N == 1 )
          return num[1];
      int res = gcd( num[1], num[2] );
      for(int i=3;i<=N;i++)
          res = gcd( num[i], res );
      return res;
  }
  
  int main()
  {
      scanf("%d", &N);
      for(int i=1;i<=N;i++)
          scanf("%d", &num[i]);
      int res = get_gcd();
      if( res != 1 )
      {
          printf("INF\n");
      }
      else
      {
          map[0] = true;
          for(int i=1;i<=N;i++)
          {
              for(int j=0;j+num[i]<10001;j++)
              {
                  if(map[j])
                      map[j+num[i]] = true;
              }
          }
          int cnt = 0;
          for(int i=1;i<10001;i++)
          {
              if( !map[i] )
              {
                  cnt++;
                  printf("%d ", i);
              }
          }
          printf("\nsum : %d\n", cnt);
      }
  
      return 0;
  }
  

9

• 题目

  标题： 分巧克力
  
      儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
      小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
  
      为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
  
      1. 形状是正方形，边长是整数  
      2. 大小相同  
  
  例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
  
  
  
  输入
  第一行包含两个整数N和K。(1 <= N, K <= 100000)  
  以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000) 
  输入保证每位小朋友至少能获得一块1x1的巧克力。   
  
  输出
  输出切出的正方形巧克力最大可能的边长。
  
  样例输入：
  2 10  
  6 5  
  5 6  
  
  样例输出：
  2
  

• 思路：采用二分查找的方法，找到最大的那个可以满足的边长。

• 代码

  #include 
  #include 
  // 将N块蛋糕分给K个人 
  int N, K;
  int h[100000], w[100000];
  
  bool ok(int k)
  {
      int sum = 0;
      for(int i=0;i= K )
              return true;
      }
      return false;
  }
  
  int main()
  {
      scanf("%d %d", &N, &K);
      for(int i=0;i 1 )
      {
          int m = (l+r)/2;
          if( ok(m) )
              l = m;
          else
              r = m;
      }
      printf("%d\n", l);
      return 0;
  }
  

10

• 题目

  标题：油漆面积
  
  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
  

• 思路：一开始是想求出所有矩形面积，减去相交的面积，求2个矩阵相交的面积可以参考https://my.oschina.net/Tsybius2014/blog/500346。但是实现之后，发现这种方法只能适用于一块区域最多处于2个矩形范围内的情况，如果3个或者以上的矩形都包围这一块，那么这种方法处理的时候有问题。后来参考了http://blog.csdn.net/qq_23070213/article/details/78795220，使用一个二维数组记录坐标系中的所有点是否被包围的情况，再进行计数，求面积。

• 代码

  #include 
  #include 
  
  int N;
  int x1[10000], x2[10000], y1[10000], y2[10000];
  
  bool map[10001][10001];
  
  int solve()
  {
      int res = 0;
      for(int i=0;i