比赛链接

A(填) 矩阵求和

方法一：

答案：

复杂度分析

时间复杂度：O()O()O()，
空间复杂度：O()O()O()，

B(填) 素数个数

用 0,1,2,3...70,1,2,3...70,1,2,3...7 这 8 个数组成的所有整数中，质数有多少个（每个数字必须用到且只能用一次）。

提示：以 0 开始的数字是非法数字。

方法一：全排列

* 熟练度问题：素数打表还是不够熟。

import java.util.*;
import java.math.*;
public class Main{static int[] nums = {0,1,2,3,4,5,6,7};static int count;private static void permutation(int k, int N) {if (nums[0] != 0 && k == N) {if (check(nums))count++;return;}for (int i = k; i < N; i++) {swap(nums, i, k);permutation(k+1, N);swap(nums, i, k);}}private static void swap (int[] arr, int l, int r) {int temp = arr[l];arr[l] = arr[r];arr[r] = temp;}private static boolean check(int[] nums) {int num = 0;for (int i = 0; i < nums.length; i++) {num = num * 10 + nums[i];}return isPrime(num) ? true : false;}private static boolean isPrime(int n) {for (int i = 2; i <= Math.sqrt(n); i++) {if (n % i == 0)return false;}return true;}public static void main(String[] args) {  int MAXN = 76543210;permutation(0, 8);System.out.println(count);}
}

答案：2668

复杂度分析

时间复杂度：O(28)O(2^8)O(28)，
空间复杂度：O(n)O(n)O(n)，

C(填) 连连看

方法一：动笔

从小到大连（先消除 1 再消除 2 …），可以得到最大分数。消掉的顺序是：

（2,2）→（1,1）→（1,1）→（2,2）→（3,3）→（4,4）→（5,5）
总和：2∗1+1∗2+1∗3+2∗4+3∗5+4∗6+5∗7=892*1+1*2+1*3+2*4+3*5+4*6+5*7=892∗1+1∗2+1∗3+2∗4+3∗5+4∗6+5∗7=89

答案：89

C(填) 加分树（A 组）

* 运算出错：小的样例算出来是 121，但不知道错在哪？

import java.util.*;
import java.math.*;
public class Main{static int[] nums = {1,2,3,4,5,6};static int[] score= {3,5,4,2,1,6};// static int[] score = {9,8,9,9,5,7,4,2,2,4,5,6,8,9,3,3,4,5,1};static int sum;public static void main(String[] args) {  // nums = new int[20];// int n = 1;// for (int i = 0; i < 20; i++) {// nums[i] = n++;//  System.out.println(nums[i]);// }TreeNode root = dfs(0, nums.length);System.out.println(find(root));}private static TreeNode dfs(int l, int r) {if (l == r) {return null;}int mid = (l + r) >>> 1;TreeNode root = new TreeNode(nums[mid]);root.score = score[mid];root.left =  dfs(l, mid);root.right = dfs(mid+1, r);return root;}//算出加分private static int find(TreeNode root) {if (root == null) {return 1;}int s = 0;if (root.left == null && root.right == null) {s += root.score;return s;}s += find(root.left) * find(root.right) + root.score;return s;}static class TreeNode {TreeNode left, right;int score, val;public TreeNode(int v) {val = v;}}
}

D(填) 快速幂

E(填)

N!N!N! 末尾有多少个 0 呢？N!=1×2×⋯×NN!=1×2×⋯×NN!=1×2×⋯×N。代码框中的代码是一种实现，请分析并填写缺失的代码。

方法一：

import java.util.*;public class Main {public static void main(String[] args) {Scanner cin = new Scanner(System.in);int n = cin.nextInt();int ans = 0;while (n != 0) {ans += /*在这里填写必要的代码*/;}System.out.println(ans);}
}

答案：

复杂度分析

时间复杂度：O()O()O()，
空间复杂度：O()O()O()，

F(设) 藏宝图

蒜头君得到一张藏宝图。藏宝图是一个 10×10 的方格地图，图上一共有 10 个宝藏。有些方格地形太凶险，不能进入。

整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。

藏宝图上从一个方格到相邻的上下左右的方格需要 1 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天。

方法一：bfs

* 核心思路：10 个宝藏和 1 个起点，共 11 个点，先求出这些点两两之间的最短路，然后对 10 个宝藏拿取的先后顺序进行全排列，最后求每次不同排列下的总路径的长度。

* 功能拆解：

初始化迷宫的宝藏坐标到 int[][] mine 中。
用 bfs 算出这 11 个点两两之间的距离到 int[][] dist 中。
对 nums={0,1,2,3,4,5,6,7,8,9} 进行全排列，每次排列计算这点两两之间的距离，最后得出总距离 sum。取最小的 sum 即可。

最后，愉快地算出 48，实不相瞒用手算效率贼高。

import java.util.*;
import java.math.*;
public class Main {final static int[][] dir = { {0,1},{0,-1},{1,0},{-1,0} };static class Pos {int x, y, dist;public Pos(int _x, int _y, int _dist) {x = _x;y = _y;dist = _dist;}}// M：宝藏；X：障碍物private static char[][] grid = { {'.','.','.','.','.','.','.','M','.','.'},{'.','.','.','X','.','.','M','.','.','.'},{'.','X','.','.','M','.','.','X','.','.'},{'.','M','.','.','.','X','.','.','M','.'},{'.','X','.','.','M','.','X','.','.','.'},{'.','.','X','.','.','.','.','X','.','.'},{'.','.','.','.','.','X','.','.','M','.'},{'.','X','.','X','.','.','M','.','.','.'},{'.','M','.','.','.','.','X','X','.','.'},{'.','.','X','.','.','X','M','.','.','.'}};final static int R = 10, C = 10;static boolean[][] vis;static int[][] mine;final static int count = 10;static int[] nums = {0,1,2,3,4,5,6,7,8,9};static int min = Integer.MAX_VALUE;static int[][] dist;public static void main(String[] args) {  vis = new boolean[R][C];mine = initMinePos();mine[10][0] = 0;   //起点坐标mine[10][1] = 0;dist = new int[count+1][count+1];//初始化每个宝藏之间的最短距离、for (int i = 0; i < count+1; i++)for (int j = 0; j < count+1; j++) {int x1 = mine[i][0], y1 = mine[i][1];   //得到两个宝藏的坐标int x2 = mine[j][0], y2 = mine[j][1];  dist[i][j] = bfs(x1, y1, x2, y2);      //算出宝藏之间的距离}//10个宝藏的发现顺序进行全排列。取出其中的最小值。permutation(0, nums.length);System.out.println(min);}// bfsprivate static int bfs(int sx, int sy, int ex, int ey) {Queue<Pos> q = new LinkedList<>();q.add(new Pos(sx, sy, 0));vis[sx][sy] = true;while (!q.isEmpty()) {Pos cur = q.poll();if (cur.x == ex && cur.y == ey) {return cur.dist;}for (int k = 0; k < 4; k++) {int tx = cur.x + dir[k][0];int ty = cur.y + dir[k][1];if (!inArea(tx, ty) || grid[tx][ty] == 'X' || vis[tx][ty]) {continue;}vis[tx][ty] = true;q.add(new Pos(tx, ty, cur.dist+1));}}return 0;}private static void find() {int sum = 0;sum += dist[10][nums[0]];  //计算起点到第一个宝藏的距离sum += dist[nums[9]][10];  //计算最后一个宝藏到起点的距离for (int i = 0; i < 9; i++) {sum += dist[nums[i]][nums[i+1]];}if (sum < min)min = sum;}private static void swap (int l, int r) {int temp = nums[l];nums[l] = nums[r];nums[r] = temp;}private static void permutation(int k, int N) {if (k == N) {find();return;}for (int i = k; i < N; i++) {swap(i, k);permutation(k+1, N);swap(i, k);}}private static boolean inArea(int x, int y) {return x >= 0 && x < R && y >= 0 && y < C;}//初始化宝藏的坐标private static int[][] initMinePos() {int[][] mine = new int[count+1][2];for (int i = 0; i < R; i++)for (int j = 0; j < C; j++) {if (grid[i][j] == 'M') {mine[i][0] = i;       //表示宝藏的横坐标mine[i][1] = j;      //表示宝藏的纵坐标}}return mine;}
}

答案：48，算了很久。

复杂度分析

时间复杂度：O(210)O(2^{10})O(210)，
空间复杂度：O(n)O(n)O(n)，

G(设) 合并数字

样例输入
4
1 2 0 1
样例输出
3

方法一：

复杂度分析

时间复杂度：O()O()O()，
空间复杂度：O()O()O()，

H(设) 蒜头君下棋

在上图中相同颜色位置所放置的马，不会相互攻击。

方法一：dfs

不难发现网格中只有两种情况：

从一个点 (i,j) 按照规则走到另一些点，这些点就是和点 (i, j) 冲突的，比如横竖竖 (i+1, y+2) 就是 -1 表示不能放马。。
然后，以当前位置 (i+1, y+2) 继续移动，所能移动到的位置就是可以放马的，即 1。
最后，网格中一定只存在 1 和 -1 这两种值，形成了一种互补的局面，取二者最大即可。

import java.util.*;
import java.math.*;
public class Main{static int R, C;static int[][] grid;static int[][] dir = {{1,2},{1,-2},{-1,2},{-1,-2},{2,1},{2,-1},{-2,1},{-2,-1}};public static void main(String[] args) {  Scanner sc = new Scanner(System.in);R = sc.nextInt();C = sc.nextInt();grid = new int[R][C];for (int x = 0; x < R; x++)for (int y = 0; y < C; y++) {if (grid[x][y] == 0) {grid[x][y] = 1;dfs(x, y);}}int cnt1 = 0;for (int x = 0; x < R; x++)for (int y = 0; y < C; y++) {if (grid[x][y] == 1)cnt1++;}System.out.println(Math.max(cnt1, R*C-cnt1));}private static void dfs(int x, int y) {for (int k = 0; k < 8; k++) {int tx = x + dir[k][0];int ty = y + dir[k][1];if (tx >= 0 && tx < R && ty >= 0 && ty < C && grid[tx][ty] == 0) {grid[tx][ty] = -grid[x][y];dfs(tx, ty);}}}
}

输入：8 8
输出：32
1 -1 1 -1 1 -1 1 -1
-1 1 -1 1 -1 1 -1 1
1 -1 1 -1 1 -1 1 -1
-1 1 -1 1 -1 1 -1 1
1 -1 1 -1 1 -1 1 -1
-1 1 -1 1 -1 1 -1 1
1 -1 1 -1 1 -1 1 -1
-1 1 -1 1 -1 1 -1 1

复杂度分析

时间复杂度：O(n×m)O(n × m)O(n×m)，
空间复杂度：O(n×m)O(n × m)O(n×m)，

I (设) 蒜头君的数轴

方法一：

复杂度分析

时间复杂度：O()O()O()，
空间复杂度：O()O()O()，

J(设) 划分整数

蒜头君特别喜欢数学。今天，蒜头君突发奇想：如果想要把一个正整数输入格式
共一行，包含两个整数 n(1 \leq n \leq 300)n(1≤n≤300) 和 k(1 \leq k \leq 300)k(1≤k≤300)，含义如题意所示。

输出格式
一个数字，代表所求的方案数。n 分解成不多于 k 个正整数相加的形式，那么一共有多少种分解的方式呢？

蒜头君觉得这个问题实在是太难了，于是他想让你帮帮忙。

输入格式

共一行，包含两个整数 n(1≤n≤300) 和 k(1≤k≤300)，含义如题意所示。

输出格式

一个数字，代表所求的方案数。

5 3
6

这种题一上来真的没啥思路，因为我们知道枚举的个数是很难确定的，所以这类问题一般用递归会比较好解决。

我们不断对整数进行递归地分割，直到这个整数不能被分割为止。比如我们想分割 4，则得到的递归树应该是这样的。

再者，我们想分割 n：

随之而来就是重叠子问题的出现。

方法一：递归（75%）

我们可以把整数划分的几种情况列举出来：

n = 1 || k = 1：表示 n 不能再被划分了；以及 n 只能被划分为 1，所以只有 1 种情况。
n > k 时，会有两种情况出现：
- 划分出来的整数包含 k：包含 k 的话，n 的大小应该缩小 k，然后再去往 n-k 里面找包含 k 的加数。
- 划分出来的整数不含 k：不包含 k，那么我只能从 k-1 里面找合适的加数。
n < k 时：表示 n 不能找到比 n 大的加数，所以，我们只能在小于 n 的数里面找。
n = k 时有两种情况：
- 加数自己就是 k。
- 因为我们不能在比 n 大数找加数，所以只能在 k-1 里面继续找加数。

* 超时错误：计算存在很多冗余，导致超时，记忆化搜索暂时没有 ac 代码，不知道错在哪里！

import java.util.*;
import java.math.*;
public class Main{public static void main(String[] args) {  Scanner sc = new Scanner(System.in);int N = sc.nextInt();int K = sc.nextInt();memo = new int[N+1][K+1];System.out.println(dfs(N, K));}//dfsprivate static int dfs(int n, int k) {if (n == 1 || k == 1)    return 1;else if (n > k) return dfs(n, k-1) + dfs(n-k, k);else if (n < k)return dfs(n, n);else return 1 + dfs(n, k-1);}
}

复杂度分析

时间复杂度：O(2n)O(2^n)O(2n)，
空间复杂度：O(n)O(n)O(n)，

方法二：dp

如果有时间的话，一定要把 dp 想出来。

【模拟赛】2018 蓝桥杯省赛 B 组模拟赛（五）相关推荐

2020年第11届蓝桥杯 C/C++ B组省赛真题详解及小结【第1场省赛2020.7.5】【Java版】
蓝桥杯 Java B组省赛真题详解及小结汇总[2013年(第4届)~2020年(第11届)] 注意:部分代码及程序源自蓝桥杯官网视频(历年真题解析) 郑未老师. 2013年第04届蓝桥杯 ...
2015年第六届蓝桥杯C/C++B组省赛题目解析
1.奖券数目有些人很迷信数字,比如带"4"的数字,认为和"死"谐音,就觉得不吉利. 虽然这些说法纯属无稽之谈,但有时还要迎合大众的需求.某抽奖活动的奖券号码是 ...
蓝桥杯c语言a组省赛试题及答案,2016-蓝桥杯-省赛-C语言大学A组全部真题.doc
第七届蓝桥杯大赛个人赛省赛真题(软件类) C/C++ 大学A组考生须知: 考试开始后,选手首先下载题目,并使用考场现场公布的解压密码解压试题. 考试时间为4小时.时间截止后,提交答案无效. 在考试强 ...
2019年第十届蓝桥杯C/C++ A组国赛赛后总结（北京旅游总结）
听说蓝桥杯挺水,几个同学一块儿报了省赛准备打着玩玩(Java C/C++ A B组都有).我报的是C/C++A组. 好,省赛一结束,一等奖前排...但是只有两个同C/C++A组的同学也是省一,不过都是 ...
第九届蓝桥杯c/c++A组省赛题解
分数题目 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + - 每项是前一项的一半,如果一共有20项, 求这个和是多少,结果用分数表示出来. 类似:3 / 2 当然,这只是加了前2项而已 ...
c语言苏小江第九章实验题答案,蓝桥杯C语言C组校内赛题目解析
今天事非常多,所有事情都凑在一起忙的不可开交.早上社团原本要搞活动,又恰好凑上实训课,三四节来不及搬东西过去,只能下课后再过去帮忙,手机没电,还是要忙到接近12点半才来得及回宿舍吃外卖. 饭还没吃几口 ...
2023第十四届蓝桥杯C/C++B组省赛题解
2023蓝桥C/C++B组省赛文章目录 2023蓝桥C/C++B组省赛试题A: 日期统计题目描述枚举参考代码试题B: 01 串的熵题目描述枚举|模拟参考代码试题C: 冶炼金属题意 ...
2017年第八届蓝桥杯C/C++ B组省赛历年真题及解析
默认阅读的你具备c/c++基本语法,作者对每一题点明需要掌握的算法策略或思想,并进行简单注释解释: 该博客的正确食用方式:简单了解点明的算法思想和策略,再自行思索之后自己写代码,提交不过再看看别人的代 ...
2017第八届蓝桥杯C/C++ B组省赛题解
前言: 毕业前最后一次蹭一次公费旅游了.以前都是在成都,这次在绵阳,至少不用早起了.应该是最后一次玩蓝桥杯了. 尊重原创,转载请注明出处:http://blog.csdn.net/y119664537 ...
（转载）2017第八届蓝桥杯C/C++ B组省赛题解
转载出处:http://blog.csdn.net/y1196645376/article/details/69718192 毕业前最后一次蹭一次公费旅游了.以前都是在成都,这次在绵阳,至少不用早起了 ...

【模拟赛】2018 蓝桥杯省赛 B 组模拟赛（五）

A(填) 矩阵求和

方法一：

复杂度分析

B(填) 素数个数

方法一：全排列

复杂度分析

C(填) 连连看

方法一：动笔

C(填) 加分树（A 组）

D(填) 快速幂

E(填)

方法一：

复杂度分析

F(设) 藏宝图

方法一：bfs

复杂度分析

G(设) 合并数字

方法一：

复杂度分析

H(设) 蒜头君下棋

方法一：dfs

复杂度分析

I (设) 蒜头君的数轴

方法一：

复杂度分析

J(设) 划分整数

方法一：递归（75%）

复杂度分析

方法二：dp

【模拟赛】2018 蓝桥杯省赛 B 组模拟赛（五）相关推荐

最新文章

热门文章