2018界 蓝桥杯Java B组代码题解

最新推荐文章于 2024-07-19 15:45:46 发布
最新推荐文章于 2024-07-19 15:45:46 发布
阅读量225 收藏
点赞数 2
分类专栏： 竞赛题解 文章标签： 算法 java 动态规划 intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45722941/article/details/104773936
版权

导言

第一次写博客,发题解,如果有哪些不符合规范的,敬请提出.
以下代码均自己所写,基本都运用暴搜的思想,一定有不完善的地方,恳求各位大佬指出,共同学习.
代码注释比较少,如果不理解的地方或者错误的地方,请在评论区指出,我定积极探讨.

第六题：递增三元组

   给定三个整数数组
    A = [A1, A2, ... AN],
    B = [B1, B2, ... BN],
    C = [C1, C2, ... CN]，
    请你统计有多少个三元组(i, j, k) 满足：

    1. 1 <= i, j, k <= N
    2. Ai < Bj < Ck
	
	【输入格式】
    第一行包含一个整数N。
    第二行包含N个整数A1, A2, ... AN。
    第三行包含N个整数B1, B2, ... BN。
    第四行包含N个整数C1, C2, ... CN。

    对于30%的数据，1 <= N <= 100
    对于60%的数据，1 <= N <= 1000
    对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

    【输出格式】
    一个整数表示答案

    【输入样例】
    3
    1 1 1
    2 2 2
    3 3 3

    【输出样例】
    27


    资源约定：
    峰值内存消耗（含虚拟机） < 256M
    CPU消耗  < 1000ms

import java.util.Scanner;
class test {
    private static int sum;
    //递归查询:n是记录已经挑选过的个数
    public static void helper(int A[], int B[], int C[], int curr[], int n, int N) {
        //递归终点,判断
        if (n == 3) {
            if (A[curr[0]] < B[curr[1]] && B[curr[1]] < C[curr[2]]) {
                sum++;
            }
        } else {
            //遍历挑选0-N的数,记录在curr数组中
            for (int i = 0; i < N; i++) {
//                int temp=curr[n];
                curr[n] = i;
                helper(A, B, C, curr, n + 1, N);
//                curr[n]=temp;//回溯这一步可有可无
            }
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] A = new int[N];
        int[] B = new int[N];
        int[] C = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = sc.nextInt();
        }
        for (int i = 0; i < N; i++) {
            B[i] = sc.nextInt();
        }
        for (int i = 0; i < N; i++) {
            C[i] = sc.nextInt();
        }
        //以上均为例题输入
        int[] curr = new int[3];
        helper(A, B, C, curr, 0, N);
        System.out.println(sum);
    }
}

测试数据:
5
1 2 1 3 4
2 2 2 3 2
3 5 1 3 5
输出:38

在这里插入图片描述

第七题：螺旋折线

    如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次。
    对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。

    例如dis(0, 1)=3, dis(-2, -1)=9

    给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？

    【输入格式】
    X和Y

    对于40%的数据，-1000 <= X, Y <= 1000
    对于70%的数据，-100000 <= X， Y <= 100000
    对于100%的数据, -1000000000 <= X, Y <= 1000000000

    【输出格式】
    输出dis(X, Y)


    【输入样例】
    0 1

    【输出样例】
    3
    
    资源约定：
    峰值内存消耗（含虚拟机） < 256M
    CPU消耗  < 1000ms


    请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

    所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是：Main，否则按无效代码处理。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class test{
    public static void main(String[] args) {
        //0,1,2,3代表北东南西,0代表横坐标,1代表纵坐标
        //dir[我面朝哪个方向][横纵坐标]=横纵坐标的变化
        int[][] dir = new int[4][2];
        {   dir[0][0]=1;
            dir[0][1]=0;
            dir[1][0]=0;
            dir[1][1]=-1;
            dir[2][0]=-1;
            dir[2][1]=0;
            dir[3][0]=0;
            dir[3][1]=1;}
        //go表示继续直走
        int[][] go=new int[4][2];
        {   go[0][0]=0;
            go[0][1]=1;
            go[1][0]=1;
            go[1][1]=0;
            go[2][0]=0;
            go[2][1]=-1;
            go[3][0]=-1;
            go[3][1]=0;}
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        int y=sc.nextInt();
        int m=-1;
        int n=0;//(m,n)记录当前点
        int key=3;//记录方向
        int dit=1;//记录距离
        //以上均为例题输入和初始化
        //Map记录该坐标有没有被走过,这里用String来表示坐标
        Map<String, Boolean> map=new HashMap<>();
        //初始化两个点,这里就假设距离大于2了,但比赛时要添加上相应输出
        map.put("00",true);
        map.put("-10",true);
        //用(m,n)来记录位置
        while (m!=x||n!=y){
            //把整数变成字符串,用来查询表:true代表走过,false代表没走过
            String c= (m+dir[key][0])+String.valueOf(n+dir[key][1]);
            if(map.containsKey(c)){//右手边走过,那么继续保持该方向
                m=go[key][0]+m;
                n=go[key][1]+n;
                //map记录该点被走过
                String d=(m)+String.valueOf(n);
                map.put(d,true);
                dit++;
            }else {//右手边没走过,向右转
                m=m+dir[key][0];
                n=n+dir[key][1];
                key=key==3?0:key+1;
                //更新map
                map.put(c,true);
                dit++;
            }
        }
        System.out.println(dit);
    }
}

测试数据: 100 -100
输出: 40200

在这里插入图片描述

第八题:日志统计

    小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
    ts id

    表示在ts时刻编号id的帖子收到一个"赞"。

    现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。

    具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。

    给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。

    【输入格式】
    第一行包含三个整数N、D和K。
    以下N行每行一条日志，包含两个整数ts和id。

    对于50%的数据，1 <= K <= N <= 1000
    对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000

    【输出格式】
    按从小到大的顺序输出热帖id。每个id一行。

    【输入样例】
   N  D  K
    7 10 2
   ts id
    0 1
    0 10
    10 10
    10 1
    9 1
    100 3
    100 3

    【输出样例】
    1
    3

    资源约定：
    峰值内存消耗（含虚拟机） < 256M
    CPU消耗  < 1000ms

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
//自定义一个类:包含了每条日志的ts与id的对应关系
class ts_id {
    int ts;
    int id;
    public ts_id(int ts, int id) { this.ts = ts;this.id = id; }
}
public class test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();//N条
        int D=sc.nextInt();//时间段
        int K=sc.nextInt();//热帖数量
        ts_id[] nums=new ts_id[N];
        for(int i=0;i<N;i++){
            nums[i]= new ts_id(sc.nextInt(),sc.nextInt());
            //若要测试10000的数则替换为:nums[i]= new ts_id((int)(Math.random()*200),((int)(Math.random()*100)));
        }//以上为例题输入
        //两个哈希表分别记录:①每条日志id和时间的关系②该id和对应的有效赞次数
        Map<Integer,Integer> id_ts=new HashMap<>();
        Map<Integer,Integer> id_time=new HashMap<>();
        for (ts_id i : nums) {
            //如果id_ts有
            if (id_ts.containsKey(i.id)){
                //如果在时间内
                if(id_ts.get(i.id)+D>i.ts){
                    id_time.put(i.id,id_time.get(i.id)+1);
                    //如果满足K,打印输出该id
                    if(id_time.get(i.id)>=K) System.out.println(i.id);
                }else {
                    //如果不在时间内,更新id_ts
                    id_ts.put(i.id,i.ts);
                }
            }else {//如果id_ts没有此记录
                id_ts.put(i.id,i.ts);
                id_time.put(i.id,1);
            }
        }
    }
}

测试数据:
7 10 2
0 1
0 10
10 10
10 1
9 1
10 3
20 10
输出:
1
在这里插入图片描述

第九题:全球变暖

    你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：

    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......

    其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。

    由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

    例如上图中的海域未来会变成如下样子：

    .......
    .......
    .......
    .......
    ....#..
    .......
    .......

    请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。

    【输入格式】
    第一行包含一个整数N。  (1 <= N <= 1000)
    以下N行N列代表一张海域照片。

    照片保证第1行、第1列、第N行、第N列的像素都是海洋。

    【输出格式】
    一个整数表示答案。

    【输入样例】
    7
    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......

    【输出样例】
    1



    资源约定：
    峰值内存消耗（含虚拟机） < 256M
    CPU消耗  < 1000ms

import java.util.Scanner;

class test {
    static int daoyu;
    private static int sum;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        char[][] graph = new char[N][N];
        for (int i = 0; i < N; i++) {
            String curr = sc.next();
            for (int j = 0; j < N; j++) {
                graph[i][j] = curr.charAt(j);
            }
        }//以上为例题输入
        //接着确定岛屿数量
        for (int i = 1; i < N - 2; i++) {
            for (int j = 1; j < N - 2; j++) {
                if (graph[i][j] == '#') {
                    graph[i][j] = '1';//把每个遍历过的岛屿都变成'1'来代替
                    check(graph, i, j, N);//查询连通块
                    daoyu++;
                }
            }
        }
        //查询被淹没后剩余岛屿的数量
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (graph[i][j] == '1' && check2(graph, i, j)) {
                    sum++;
                }
            }
        }
        System.out.println(daoyu - sum);
    }
    //查询DFS连通块
    public static void check(char[][] graph, int i, int j, int N) {
        if (i != N && graph[i + 1][j] == '#') {
            graph[i + 1][j] = '1';
            check(graph, i + 1, j, N);
        }
        if (j != N && graph[i][j + 1] == '#') {
            graph[i][j + 1] = '1';
            check(graph, i, j + 1, N);
        }
        if (i != 0 && graph[i - 1][j] == '#') {
            graph[i - 1][j] = '1';
            check(graph, i - 1, j, N);
        }
        if (j != 0 && graph[i][j - 1] == '#') {
            graph[i][j - 1] = '1';
            check(graph, i, j - 1, N);
        }
    }
    //判断周围有没有海
    public static boolean check2(char[][] graph, int i, int j) {
        if (graph[i - 1][j] == '1' && graph[i][j - 1] == '1' && graph[i + 1][j] == '1' && graph[i][j + 1] == '1')
            return true;
        return false;
    }
}

测试数据:
9
…
…##…##.
.###…##.
.#####…
.#…##.
.#…###…
.#…####.
…#…
…
打印结果:1
在这里插入图片描述

第十题:堆的计数(不好意思没做出来,附上第一次思想代码,留给我自己看)

    我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
    每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。

    假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？

    例如对于N=4有如下3种：

    1
    / \
    2   3
    /
    4

    1
    / \
    3   2
    /
    4

    1
    / \
    2   4
    /
    3

    由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。


    【输入格式】
    一个整数N。
    对于40%的数据，1 <= N <= 1000
    对于70%的数据，1 <= N <= 10000
    对于100%的数据，1 <= N <= 100000

    【输出格式】
    一个整数表示答案。

    【输入样例】
    4

    【输出样例】
    3


    资源约定：
    峰值内存消耗（含虚拟机） < 256M
    CPU消耗  < 1000ms

class treeNode{
    int val;
    treeNode left;
    treeNode right;
    public treeNode(int x){
        this.val =x;
    }
}
class _2018 {
    static int sum;
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int[] nums=new int[sc.nextInt()];
        for (int i=0;i<nums.length;i++){
            nums[i]=i;
        }
        helper(nums.length,0,nums);
        System.out.println(sum);
    }
    public static void helper(int n, int curr,int[] nums){
        if(curr==n){
            if(nums[0]!=1) return;
            treeNode root=new treeNode(1);
            if (check(nums,1,root)) sum++;
        }else {
            for(int i=curr;i<n;i++){
                {int temp=nums[curr];
                    nums[curr]=nums[i];
                    nums[i]=temp;}
                helper(n, curr + 1, nums);
                int temp=nums[curr];
                nums[curr]=nums[i];
                nums[i]=temp;
            }
        }
    }
    //检查是否符合树的条件
    private static boolean check(int[] nums,int i,treeNode root) {
        if(i+1==nums.length-1) return nums[i+1]>nums[i];
        if(nums[i+1]>nums[i]){
            root.left=new treeNode(nums[i+1]);
            boolean c=check(nums,i+1,root.left);
            root.right=new treeNode(nums[i+1]);
            boolean d=check(nums,i+1,root.left);
            if(c&&d) sum=sum+1;
            return c||d;
        }
        return false;
    }
Beis
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018蓝桥杯JavaB组第三题
Xsa_666的博客
01-22 284
题目 设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。 求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。 过程 首先要知到复数的计算公式:设z1=a+bi，z2=c+di(a、b、c、d∈R)是任意两个复数，那么它们的积(a+bi)(c+di)=(ac-bd)+(bc+ad)i。利用这个关系,用BigInterger去计算接收结果(因为尝试long型不可以),再用一个while循环即可,记得保留一个初始的变量不变,一..
2018年第九届蓝桥杯真题Java B组
壹小崔的博客
04-01 1537
2018年第九届蓝桥杯真题Java B组1、标题：第几天2000年的1月1日，是那一年的第1天。那么，2000年的5月4日，是那一年的第几天？注意：需要提交的是一个整数，不要填写任何多余内容。2、标题：方格计数如图p1.png所示，在二维平面上有无数个1x1的小方格。我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。你能计算出这个圆里有多少个完整的小方格吗？ 注意：需要提交的是一个整数，不...
蓝桥杯练习系统参考代码java版
11-20
蓝桥杯练习系统java参考答案 只有入门训练、基础练习和历届试题 算法训练和算法提高后续补充
2018年第九届蓝桥杯JAVA B组 题解——更新中
热门推荐
yxb的博客
04-13 1万+
成绩出来了，还是可以去北京玩了，本来以为无缘的。。。加油吧决赛 第一题 标题：第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 解：125，31+29+31+30+4=125（有输入法可以打v然后输入式子直接计算，或者直接sysout计算； 第二题 ...
JAVA 蓝桥杯比赛
03-08
蓝桥杯比赛试题 模拟题，内容与比赛相关性强
蓝桥杯 数的划分(动态规划分析)
一个很懒的人
07-22 1142
题目信息： 问题描述 　　将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。 　　例如：n=7，k=3，下面三种分法被认为是相同的。 　　1，1，5; 1，5，1; 5，1，1; 　　问有多少种不同的分法。 　　 输入格式 　　n，k 　　 输出格式 　　一个整数，即不同的分法 　　 样例输入 7 3 样例输出 4 {四种分法为：1，1，5;1，2，4;1，3，3;2，2，3;} 数据规模和约定 　　6<n<=200，2<=k<=6 动态规划分析： 这道题目有点
蓝桥杯-2018年蓝桥杯竞赛VIP题目+题解
11-11
蓝桥杯_2018年蓝桥杯VIP题+题解 蓝桥杯全国软件和信息技术专业人才大赛，简称蓝桥杯，是一个信息技术类型的高级高校竞赛 资源内包含了 2018 年蓝桥杯竞赛数据、竞赛题与题解 希望对你的学习有一点帮助。
2013-2018年蓝桥杯决赛个人题解.txt
05-20
这里面包含Java B组2013年到2018年北京决赛的所有题目，以及每题都给出了解析和代码。
蓝桥杯竞赛练习题的题解(CC++Java).zip
05-10
蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯竞赛练习题的题解(CC++Java)蓝桥杯...
蓝桥杯 蓝桥杯竞赛练习题的题解
05-23
**内容概要**：本资源提供了蓝桥杯竞赛练习题的详细题解，涵盖了不同难度和类型的题目，包括基础算法、数据结构、数学建模、动态规划、图论、字符串处理等。每道题解都包括题目描述、思路解析、代码实现和运行结果。...
C、C++、Java -蓝桥杯竞赛练习题的题解
06-04
蓝桥杯大赛是由工业和信息化部人才交流中心主办，国信蓝桥教育科技（北京）股份有限公司承办的全国性IT学科赛事。 蓝桥杯自2009年开始举办，至今已成功举行了13届。这项赛事旨在提高大学生的创新和实践能力，为信息...
2017 第八届蓝桥杯 魔方状态
qq_35222235的博客
03-28 1万+
标题：魔方状态二阶魔方就是只有2层的魔方，只由8个小块组成。如图p1.png所示。小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：前面：橙色右面：绿色上面：黄色左面：绿色下面：橙色后面：黄色请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。请提交表示状态数的整数，不要填写任何多余内容或说明文字。开...
蓝桥杯入门训练Java代码
ljy320672584的博客
06-11 820
** 蓝桥杯入门训练Java代码 蓝桥杯入门训练四道题的试题与代码均在。由于本人此次参加蓝桥杯为Java组，所以一直都用Java练习。故代码只写了Java的代码。 1.试题 入门训练 A+B问题 提交此题 评测记录 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 输入A、B，输出A+B。 说明：在“问题描述”这部分，会给出试题的意思，以及所要求的目标。 输入格式 输入的第一行包括两个整数，由空格分隔，分别表示A、B。 说明：“输入格式”是描述在测试你的程序时，所给的输入一定满足的格
场景题java_b场景算法题（Java实现）
weixin_31299543的博客
02-27 443
、字母倒着输出题目描述：给定一组字符串，然这组字符串中的字母按照倒着的顺序输出,空格保留。例如：输入：i am a student输出：student am i代码如下：import java.util.Scanner;public class Main4 {public static void main(String[] args) {Scanner in = new Scanner(Syste...
2018年第九届蓝桥杯国赛试题及详解（Java本科B组）
weixin_41549033的博客
05-23 329
1.标题：三角形面积 已知三角形三个顶点在直角坐标系下的坐标分别为： (2.3, 2.5) (6.4, 3.1) (5.1, 7.2) 求该三角形的面积。 注意，要提交的是一个小数形式表示的浮点数。 要求精确到小数后3位，如不足3位，需要补零。 2.标题：最大乘积 把 1~9 这9个数字分成两组，中间插入乘号， 有的时候，它们的乘积也只包含1~9这9个数字，而且每个数字只出现1次。 比如： 98...
经典动态规划算法题（Java实现）
qq_42862882的博客
05-01 7152
待更新
第十一届蓝桥杯Java B组C题蛇形填数
ccccduo的博客
03-12 208
思路一: 找规律。第一行第一列为1，第二行第二列为5，第三行第三列为13……，可以看出： 从第一行第一列开始，每增加一行一列数字增大n*4。所以算出1+5+13+25……的和即可。 源代码： public class C1{ public static void main(String[]args){ int num = 1;//第一行第一列为1 for(int i = 1;i < 20;i++){ num += i*4;//从第一行.
Leetcode—207. 课程表【中等】
最新发布
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
蓝桥杯B组题解：九进制转十进制、顺子日期统计与算法挑战
在蓝桥杯B组个人题解文档中，包含了五道不同的IT编程题目，涉及了基础的编程技巧和算法思维。以下是每个题目的详细解析： 1. **试题A：九进制转十进制** (5分) 这是一道基础的数学转换题目，要求将一个九进制数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值