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

最新推荐文章于 2021-04-08 20:25:52 发布
最新推荐文章于 2021-04-08 20:25:52 发布
阅读量228 收藏
点赞数
分类专栏： ACMer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36706625/article/details/79691879
版权

总链接：https://www.jisuanke.com/contest/1215

A:矩阵求和


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class A {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int sum = 0, c = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                c++;
                if (Math.abs(n / 2 - i) + Math.abs(n / 2 - j) <= n / 2) {
                    sum += c;
                }
            }
        }

        out.println(sum);
        out.flush();

    }

}

B:素数个数

全排列、0->7 如果前面的不是0、就判断是不是素数、统计输出

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class B {

    static boolean vis[] = new boolean[9]; //  0 -> 8  
    static int a[] = new int[10]; // 0 -> 8
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static long sum = 0;
    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) {
        sum = 0;
        dfs(0);
        out.println(sum);
        out.flush();
    }

    private static void dfs(int s) {
        if (s == 8) {
            if(a[0] == 0){
                return ;
            }else{
                String str = "";
                for(int i = 0; i < 8; i++){
                    str += a[i];  
                }
                int num = Integer.parseInt(str);
                if(judge(num)){
                    sum++;
                }
            }
            display();
        }

        for (int i = 0; i < 8; i++) {
            if (!vis[i]) {
                vis[i] = true;
                a[s] = i;
                dfs(s + 1);
                vis[i] = false;
            }

        }
    }

    public static boolean judge(int num) {
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if(num % i == 0){ // 不是素数、、
                return false;
            }
        }
        return true;
    }

    public static void display() {
        for (int i = 0; i < 8; i++) {
            out.print(a[i] + " ");
        }
        out.println();
        out.flush();
    }
}

c：连连看

dfs求解边界的点、（类似于全排列）枚举出所有的情况、然后不断的取最大的结果

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class C {

    static int fd[][] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; //设置上下左右四个方向、、、
    static boolean vis[][] = new boolean[21][21];
    static int a[][] = new int[21][21];
    static int n, ans;
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        n = nextInt();
        ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = nextInt();
            }
        }
        dfs(1, 0);
        out.println(ans);
        out.flush();
    }

    private static boolean judge(int x, int y) {
        if (vis[x][y]) {
            return false;
        }

        for (int i = 0; i < 4; i++) {
            int xx = x + fd[i][0];
            int yy = y + fd[i][1];
            if (xx < 0 || xx >= n|| yy < 0 || yy >= n) { //在边界、、、
                return true;
            }
            if (vis[xx][yy]) { //　使用过、、、
                return true;
            }
        }
        return false;
    }

    private static void dfs(int step, int s) {
        ans = Math.max(ans, s);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(judge(i, j)){  // 是边界、 可以消除、、、
                    for(int ii = 0; ii < n; ii++){
                        for(int jj = 0; jj < n; jj++){
                            if(ii == i && jj == j){
                                continue;
                            }
                            if(a[i][j] == a[ii][jj] && judge(ii, jj)){
                                vis[i][j] = vis[ii][jj] = true;
                                dfs(step + 1, s + step * a[i][j]);
                                vis[i][j] = vis[ii][jj]= false;
                            }
                        }
                    }
                }
            }
        }
    }
}

D：快速幂、

快速幂的基础知识、不懂得就去百度一下吧、

E：末尾的0的个数

要想有0、那就必须有10、既然有10、那一定有5、2、而2又比5多、所以有0个个数也就是有5的数量

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Scanner;

public class E {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int tmp = n;
        int ans = 0;
        while (n != 0) {
            ans += (n /= 5);
        }
        System.out.println(ans);
        long sum = 1;
        for(int i = 1; i <= tmp; i++){
            sum = sum * i;
        }
        System.out.println(sum);
    }
}

F:藏宝图

（待续）

G:合并数字

用堆栈来维护、每次合并的个数、如果要新加入的小于栈顶数1、那栈顶弹出、大于栈顶的话、那就继续输入、否则就压入栈中、最终输出次数

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Stack;

public class G {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        int n, cnt = 0, x;
        Stack<Integer> stack = new Stack<>();
        n = nextInt();
        for(int i = 0; i < n; i++){
            x = nextInt();
            while(!stack.isEmpty() && stack.peek() - x == 1){ // 栈顶元素比这个大、删除、 不比这个大就结束循环、
                stack.pop();
                cnt++;
            }
            if(!stack.isEmpty() && x - stack.peek() == 1){ // 这个数比当前栈顶的大、而且恰好大 1 
                cnt++;
            }else{
                stack.push(x);  // 扔进去称为栈顶、、、
            }
        }
        out.println(cnt);
        out.flush();
    }
}

H:蒜头君下棋


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class H {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static int n, m;

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        n = nextInt();
        m = nextInt();
        solve();
    }

    private static void solve() {
        if (n < m) {  // 保证 n是最大的、、然后我们来对小的进行处理、、、
            int tmp = n;
            n = m;
            m = tmp;
        }
        
        if(m == 1){
            out.println(n);
        }else if(m == 2){
            out.println(n / 4 * 4 + Math.min(n % 4, 2) * 2);
        }else{
            out.println((n * m + 1) / 2);
        }
        out.flush();
    }
}

I：蒜头君的数轴

考虑两对相邻点距离怎么由不同的通过加点变为全部相同, 也就是对线段进行分割, 分割成相同长度的若干段, 这个长度最大也就是原来两条线段长度的最大公约数, 我们先对点排好序然后做差,得到相邻点距离,因为最多允许有一段距离跟其它不同,可以枚举不同的是哪一段, 对其它段求最大公约数。

怎么快速求出这个值, 可以运用前缀和的思路, 预处理出前缀

gcd和后缀 gcd, 那么其它段的 gcd就可以通过这两个 gcd再求一遍 gcd得到。 得到分割后的距离后, 每一段需要加的点就可以算了, 但是如果每一次都去看每一段要加多少点还是太慢了, 我们可以预处理得到最左点和最右点的距高, 减去枚举中的那一 段, 再除以最大公约数得到一共会被分成多少小段, 需要加的点数就是这个数字减去原来有多少段,也就是减去 n-2。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class I {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static final int MAXN = 100005;
    static int dist[] = new int[MAXN];
    static int gcd1[] = new int[MAXN];
    static int gcd2[] = new int[MAXN];

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    /*
    只有一对点与其他的不同的话、就是最左边或者最右边的俩个点、、、
     */
    public static void main(String[] args) throws IOException {

        int n = nextInt();
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        Arrays.sort(a); // 排序、、
        out.println(solve(a));
        out.flush();
    }

    public static int gcd(int a, int b) { // 求最大公因数、、
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int solve(int[] a) {
        int len = a.length;
        if (len <= 3) {
            return 0;
        }
        int sum = 0;
        for (int i = 0; i < len - 1; i++) {
            dist[i] = a[i + 1] - a[i];
            sum += dist[i];
        }
        gcd1[0] = dist[0];
        for (int i = 1; i < len - 1; i++) {
            gcd1[i] = gcd(gcd1[i - 1], dist[i]);
        }
        gcd2[len - 2] = dist[len - 2];
        for (int i = len - 3; i >= 0; i--) {
            gcd2[i] = gcd(gcd2[i + 1], dist[i]);
        }
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < len - 1; i++) {
            int d;
            if (i == 0) {
                d = gcd2[i + 1];
            } else if (i == len - 2) {
                d = gcd1[i - 1];
            } else {
                d = gcd(gcd1[i - 1], gcd2[i + 1]);
            }
            ans = Math.min(ans, (sum - dist[i]) / d - len + 2);
        }
        return ans;
    }
}

J：划分整数



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class J {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static final int MAXN = 305;
    static long dp[][] = new long[MAXN][MAXN];

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        int n, k;
        n = nextInt();
        k = nextInt();
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= k; j++){
                if(i == 1 || j == 1){
                    dp[i][j] = 1;
                }else if(j > i){
                    dp[i][j] = dp[i][i];
                }else if(i == j){
                    dp[i][j] = dp[i][j - 1] + 1;
                }else{
                    dp[i][j] = dp[i][j - 1] + dp[i - j][j];
                }
            }
        }
        out.println(dp[n][k]);
        out.flush();
    }
}

浮沉_y
关注
专栏目录
计蒜客 2018蓝桥杯省赛 B组模拟赛（五） C题 连连看(java)
Tim的嵌入式之旅
03-27 465
【题目链接】：https://nanti.jisuanke.com/t/25086【题目描述】：连连看是一款非常有意思的游戏。我们可以把任意两个在图的在边界上的相同的方格一起消掉，比如把两个 4 消掉以后，每次消掉两个方格的时候，都有会获得一个分数，第 i 次消的分数为 i× 方格的值。比如上面的消法，是第一次消，获得的分数为 1×4=4。请你帮忙最优操作情况下，获得的分数最多为多少。答案：89过...
2018 蓝桥杯省赛 B 组模拟赛（五）—— 末尾零的个数
渣渣琪的博客
03-25 298
题目：思路见下：package jisuanke; import java.util.*; /* 如计算 2009! 的末尾有多少个0: 2009/5 = 401 1~2009之间有 401 个数是 5 的倍数(余数省略).401/5 = 80 1~2009 之间有 80 个数是 25 的倍数.80/5 = 16 1~2009 之间有 16 个数是 125 的倍数. 16/5 = 3 ...
2018年第九届蓝桥杯省赛真题C/C++(B组)
04-01
2018年第九届蓝桥杯省赛真题 C/C++ 语言大学B组原题。
出模拟赛
略略的博客
04-08 728
题目 有三种难度的题目难度分别为Easy,Medium,Hard。现在你总共有 E+EM+M+MH+H 道题，各个字符串的含义如下: E表示有E道题目难度为Easy。 EM表示有EM道题目难度可以为Easy或Medium。 M表示有M道题目难度为Medium。 MH表示有MH道题目难度可以为Medium或Hard。 H表示有H道题目难度为Hard。 你要用这些题目出尽量多的模拟赛，为了保证题目质量且含有一定的区分度，每场模拟赛需要包含Easy,Medium,Hard 三种难度的题目各一道。求你最多能出多少场
网易有道嵌入式 最多能出多少场模拟赛 二分法 80%
qq_24624539的博客
08-08 718
有三种难度的题目难度分别为Easy,Medium,Hard。现在你总共有 E+EM+M+MH+H道题，各个字符串的含义如下: 1. E表示有E道题目难度为Easy。 2. EM表示有EM道题目难度可以为Easy或Medium。 3. M表示有M道题目难度为Medium。 4. MH表示有MH道题目难度可以为Medium或Hard。 5. H表示有H道题目难度为Hard。 你要用这些题目出尽量多的模拟赛，为了保证题目质量且含有一-定 的区分度，每场模拟赛需要包含Easy,Medium,Hard三种难度的题 目
2019 蓝桥杯省赛 B 组模拟赛（四） 程序设计：队列
qq_41998938的博客
03-11 194
题目： 代码如下： 50%数据 #include&lt;bits/stdc++.h&gt; using namespace std; #define MAX 50005 vector&lt;int&gt; a[MAX]; int f[MAX]; int father(int x) { while(x != f[x]) x = f[x]; return x; } void combine(i...
Scanner类中的nextToken()方法解读
06-05 3222
下面看一下nextToken()方法的源码实现。 1、Java中的控制字符 case ' ': // (Spec 3.6) case '\t': // (Spec 3.6) case FF: // (Spec 3.6) 换页符 换页字符 do { scanChar(); // 操作的是bufferpointer指针的值 ...
2018省赛第九届蓝桥杯真题C(B组)
04-01
【标题】"2018省赛第九届蓝桥杯真题C(B组)"涉及到的是一个编程竞赛的真题集，主要针对C语言参赛者。蓝桥杯是全国知名的编程比赛，旨在提升大学生的计算机软件设计能力和创新思维，对参赛者的C语言基础和算法理解有较...
计蒜客 2018蓝桥杯省赛 B组模拟赛（一） D题 LIS(java)
Tim的嵌入式之旅
03-26 545
LISLIS是最长上升子序列。什么是最长上升子序列？ 就是给你一个序列，请你在其中求出一段最长严格上升的部分，它不一定要连续。就像这样：2, 3, 4, 7 和 2, 3, 4, 6 就是序列 2 5 3 4 1 7 6 的两个上升子序列，最长的长度是 4。结果：f[i]=max(f[i], f[j]+1)；思路：其实这是一道动态规划的问题，最长不降子序列。这道题类似于：https://blog....
蓝桥杯省赛：2018年B组C++（第九届）题目及答案
04-03
2018年的第九届蓝桥杯省赛B组主要针对C++语言的编程技能进行考核，为参赛者提供了丰富的题目类型，包括但不限于算法设计、数据结构应用、逻辑推理等。这些题目旨在测试选手们对C++语言的理解，以及他们在实际问题...
ACM快速输入输出
王跃坤的博客
11-17 1450
package 输入输出; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.StreamTokenize...
字典序 java_字典序问题(Java)
weixin_28707365的博客
02-20 895
Description在数据加密和数据压缩中常需要对特殊的字符串进行编码。给定的字母表A由 26 个小写英文字母组成A={a,b,…,z}。该字母表产生的升序字符串是指字符串中字母按照从左到右出现的次序与字母在字母表中出现的次序相同，且每个字符最多出现1次。例如，a,b,ab,bc,xyz等字符串都是升序字符串。现在对字母表A 产生的所有长度不超过6 的升序字符串按照字典序排列并编码如下。 对于任...
PrintWriter和OutputStreamWriter的使用
Gemini_Kanon的博客
05-13 1940
这几天小编被乱码这哥们儿坑稀了，搞了好一阵子才弄出来，不过我遇到的只是一种情况，其他情况以后遇到再来说！ 我的项目需要调用第三方接口来获取数据，刚开始我给服务器那边传参的编码格式不对，导致入参和返回数据都是乱码；但是我把入参的编码格式改成UTF-8后返回的数据还是乱码，我感觉应该就是题目中这两个流的事儿了，下面贴代码： 字符串转编码： String text = "{\"haha\":\"...
PrintWriter writer = new PrintWriter(socket.getOutputStream())出现的问题
weixin_44765605的博客
06-07 2439
PrintWriter writer = new PrintWriter(socket.getOutputStream()); 今天在做作业的时候，这个东西卡了我很久。。。 问题： 我的服务端一直接收不到客户端的信息，但是debug的时候，客户端发送信息是全部发送出去了的，而服务端却一直阻塞在等待信息中。后来通过查找资料和试验，我才解决了这个问题。     问题代码： 客户端发送信息： writer.write(tUsername.getText()); writer.write(tP
8.8 网易笔试
Autter的博客
08-08 1413
分析 时间：1个小时40分钟 四道题,难度还可以，太菜只写出了第一道第三道 1、 牛牛现在有一个包含N的正整数的数组a，牛牛可以将其中的每个数a[i] 都拆成若干个和为 a[i] 的整数，牛牛想知道这个数组最多能有多少素数？ 输入描述 第一行一个正整数n表示数组的长度 第二行n个正整数表示a[i]的值 1 <= n <= 1e6，1 <= a[i] <= 1e9 输出描述 拆后数组最多的素数个数 示例1 输入 3 1 1 1 输出 0 说明 由于1不能再拆，并且1不是素数，所
2018蓝桥杯省赛java_蓝桥杯2018年A组省赛
weixin_35531779的博客
03-05 267
1.分数1/1 + 1/2 + 1/4 + 1/8 + 1/16 + …每项是前一项的一半，如果一共有20项,求这个和是多少，结果用分数表示出来。类似：3/2当然，这只是加了前2项而已。分子分母要求互质。#include using namespace std;#define REP(i,n) for(int i=0;i#define FOR(i,a,b) for(int i=a;i<=b;...
2018 蓝桥杯省赛 B 组模拟赛（一）
有需要下载东西的可以私聊我
03-09 1718
1.今天蒜头君带着花椰妹和朋友们一起聚会，当朋友们问起年龄的时候，蒜头君打了一个哑谜（毕竟年龄是女孩子的隐私）说：“我的年龄是花椰妹年龄个位数和十位数之和的二倍”。花椰妹看大家一脸懵逼，就知道大家也不知道蒜头君的年龄，便连忙补充道：“我的年龄是蒜头君个位数和十位数之和的三倍”。请你计算：蒜头君和花椰妹年龄一共有多少种可能情况？提醒：两位的年龄都是在 [10,100)[10,100) 这个区间内。这...
蓝桥杯省赛C/C++ B组：跑步训练题目详解
该资源是关于第十一届蓝桥杯软件类省赛C/C++大学B组的比赛题目，主要针对的是参赛选手在比赛中的规定和一个具体问题的实例。蓝桥杯是一项重要的大学生信息技术竞赛，C/C++大学B组的试题旨在考察选手的算法设计和编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值