2019年 第十届 蓝桥杯省赛 C/C++ B 组 学习总结

试题A：组队

给出的输入数据

1 97 90 0 0 0
2 92 85 96 0 0
3 0 0 0 0 93
4 0 0 0 80 86
5 89 83 97 0 0
6 82 86 0 0 0
7 0 0 0 87 90
8 0 97 96 0 0
9 0 0 89 0 0
10 95 99 0 0 0
11 0 0 96 97 0
12 0 0 0 93 98
13 94 91 0 0 0
14 0 83 87 0 0
15 0 0 98 97 98
16 0 0 0 93 86
17 98 83 99 98 81
18 93 87 92 96 98
19 0 0 0 89 92
20 0 99 96 95 81

答案：490

#include <iostream>
using namespace std;

int visited[21];
int score[21][6];

int mmax = 0;       //最大值 

void dfs(int p, int sum)
{
    if(p > 5)     //枚举到完5个位置 
    {
        if(sum > mmax)  mmax = sum;  
    }
    else
    {
        for(int i = 1; i <= 20; i ++) //枚举20位 球员 
        {
            if(visited[i] == 0)  //如果没有用过 
            {
                visited[i] = 1; //使用 
                dfs(p + 1, sum + score[i][p]); //加上位置 p 的成绩 
                visited[i] = 0; //回溯 
            }
        }
    }
}

int main()
{
     for(int i = 1; i <= 20; i ++)
     {
     	int x; cin >> x; //去掉序号
         for(int j = 1; j <= 5; j ++)
         {
             cin >> score[i][j];    
         }
     }
     dfs(1, 0); //枚举 位置一 
     cout << mmax << endl;
 // cout << "490"; 
 //本题为填空题 蓝桥杯官网上提交代码也没有测试数据给你的，
 //所以提交代码的时候直接手动输出结果即可
    return 0;
}

试题B：年号序列

解析：感觉就像26进制 A-Z有26个字母，Z再大就进一位 变成AA,所以有进制转换的规律。2019 > 26*26 所以有三位。
答案:BYQ

#include <iostream>
using namespace std;
int main()
{
  int n = 2019 ;
  int a = n / 26 / 26;
  int b = n / 26 % 26;
  int c = n % 26;
  cout <<(char)(a + 64) ;
  cout <<(char)(b + 64) ;
  cout <<(char)(c + 64) ;
  return 0;
}

试题C：数列求和

答案：4659
解析：既然它只要后4位，那我们每次就 直接模 10000 这样也可以避免爆int对吧。

#include <iostream>
using namespace std;
const int N = 21000000;
int a[N];
int main()
{
  a[1] = a[2] = a[3] = 1; //初始化数据
  for(int i = 4; i <= 20190324; i ++)
  	a[i] = (a[i - 3] + a[i - 2] + a[i - 1]) % 10000;
  cout << a[20190324];
  return 0;
}

试题D：数的分解

答案：40785
解析：三个数加起来等于2019，我们可以枚举两个数 另外一个数算出来就好了 k = 2019 - i - j,然后检查这三个数有包含 2 或 4

#include<iostream>
 using namespace std;
 int res;
bool check(int x)
{
    while(x)
    {
        if(x % 10 == 4 || x % 10 == 2) return false;//不合法条件 
        x /= 10;
    }
    return true;
}
int main()
{
    for(int i = 1; i < 2018; i ++)
    {
        for(int j = i + 1; j < 2018; j ++)
        {
            int k = 2019 - i - j;
            if(check(j) && check(i) && check(k) && i < j && j < k)
            //检查三个数 符合条件就 ++
                res++;
        }
    }
    cout << res;
    return 0;
}

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

试题E ：迷宫

解析：使用BFS遍历，用的队列存储结构体，结构体类有现在位置的坐标，和走的最优路径的字符串。
注释下的 队列的push需要支持C++11才行，不然会有警告

#include <iostream>
#include <queue>
#include <cstring> 
using namespace std;
int n = 30, m = 50;
const int ax[4]={1,0,0,-1};
const int ay[4]={0,-1,1,0};
char g[40][60]; //存储迷宫
bool visit[40][60]; 
const char dir[5]={'D','L','R','U'};
struct point{
    int x,y;
    string ans;
     point(int a, int b, string c){
       x=a;y=b;ans=c;
     };
};
void bfs()
{
    //初始化 
    queue<point>ans; //BFS队列
    ans.push(point(1,1,""));
  // ans.push({1, 1, ""});
    visit[1][1] = true;
    
    //开始BFS
    while(!ans.empty())
    {
        point temp = ans.front(); //取出
        ans.pop();
        if(temp.x == n && temp.y == m) { cout << temp.ans <<endl; return ;}  //结束访问
            for(int i=0;i<4;i++) {
                int dx = temp.x + ax[i];
                int dy = temp.y + ay[i];
                if(!visit[dx][dy] && g[dx][dy] != '1') {
                    visit[dx][dy] = true;
                    //ans.push({dx, dy, temp.ans + dir[i]});
                    ans.push(point(dx,dy,temp.ans + dir[i]));
            }
        }
     } 
    
    
}
int main()
{

  memset(g, '1',sizeof g);
  for(int i = 1; i <= n; i ++)
      for(int j = 1; j <= m; j ++) cin >> g[i][j];
  bfs();

  return 0;
}

试题F：特别数的和

解析：直接暴力

#include <iostream>
using namespace std;
int main()
{
  int n, res = 0; 
  cin >> n;
  for(int i = 1; i <= n; i ++)
  {
      int temp = i;
      while(temp)
      {
          int y = temp % 10;
          temp /= 10;
          if(y == 2 || y == 0 || y == 1 || y == 9) 
          {
              res += i;
              break;
          }
      }
  } 
  cout << res;
  return 0;
}

试题G：完全二叉树的权值

解析：

• 第1层 ：1个数 = 2⁰ = 1 << 0 左移操作，知道对应是2的x次方就行
• 第2层 ：2个数 = 2¹ = 1 << 1
• 第3层 ：4个数 = 2² = 1 << 2
• 第3层 ：8个数 = 2³ = 1 << 3
  所以就第一层的总和记下来，与第二层总和比，记下总和大的 的总和数 和 层数

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
int a[N];
int main()
{
  int n; cin >> n;
  LL dnum = -1e18, maxd = 0;
  for(int i = 1; i <= n; i ++) scanf("%d",&a[i]);
  //从第一层开始 直到结点个数到n； i*=2就是每层的开始位置了 
  for(int d = 1, i = 1; i <= n; i *= 2, d ++ )
  {
       LL tsum = 0; //记录本层总和
       //i + (1 << d - 1) 就是 本层起点 + 本层个数 
       for(int j = i; j < i + (1 << d - 1) && j <= n; j ++)
       {
           tsum += a[j];
       }
       if(tsum > dnum) //比较 记录
       {
           dnum = tsum;
           maxd = d;
       }
  }
  cout << maxd;
  return 0;
}

试题H：等差数列

解析：
做法：排序数列,之后计算相近两数的差值，然后这些差值的最大公约数就是最大的公差了。
举个例子： 6 10 20 28
求出相邻两数的差 4 ，10 ，8 可能潜意识会选最小的 4，
但是 选了4以后 10 到 20 就是 10 14 18 22 了 根本不会出现20
所以需要选择4 10 8的最大公约数 2 作为公差才合法
我们的目的的数列的最短个数：(最大项 - 最小项) / d + 1
然后这题有个坑 就是公差为0时要特判一下，不然除数为 0 会报错

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5;
int num[N];  
int d = 0;
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}
int main()
{
  // 请在此输入您的代码
  int n; cin >> n; 
  for(int i = 0; i < n; i ++)
  {
      cin >> num[i];
  }
  sort(num, num + n);
  for(int i = 1; i < n; i ++)
  {
      d = gcd(d, num[i] - num[i - 1]);
  }
   if(num[n - 1] - num[0] == 0)
  {
    cout << n;
  }else{
   cout << (num[n - 1] - num[0])  / d + 1;
 }
  return 0;
}

试题I：后缀表达式

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 5;
int a[2*N];
int n,m;
typedef long long LL;
int main()
{
    scanf("%d%d", &n, &m);
    int k = n + m + 1;
    for(int i = 0; i < k; i ++) scanf("%d",&a[i]);
    LL res = 0;
    
    
    if(!m){
    //无减号 无操作
        for(int i = 0; i < k; i ++)
           res += a[i];
    }else{
    //有减号 起死回生
          sort(a, a + k);
          res = a[k - 1] - a[0]; //加最大数 - 最小数 其余取绝对值
          for(int i = 1; i < k - 1; i ++) res += abs(a[i]);
    }
    printf("%lld\n", res);
    return 0;
}

试题 J: 灵能传输（放弃）

看到题目我就算了·····