2016年第七届蓝桥杯省赛Java B组真题+个人题解

已于 2023-04-04 15:32:55 修改
阅读量129 收藏
点赞数 1
分类专栏： 蓝桥杯历届真题 文章标签： 算法 java 数据结构 蓝桥杯
于 2023-04-04 15:31:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/God4121226224/article/details/129923815
版权

目录

一、煤球数目

二、生日蜡烛

三、凑算式

六、方格填数

七、剪邮票

八、四平方和

九、取球博弈

十、压缩变换

一、煤球数目

蓝桥杯官网_煤球数量

 思路:

分析可知: 每一层的煤球数量=上一层的煤球数量+当前层数

答案:

171700

代码:

import java.io.IOException;
import java.io.PrintWriter;

public class Main {
    static PrintWriter pw=new PrintWriter(System.out);
    static int a[]=new int[110];//存储每层的煤球个数
    public static void main(String args[]) throws IOException{
        int res=0;
        for(int i=1;i<=100;i++){
            a[i]=a[i-1]+i;
            res+=a[i];
        }
        pw.println(res);
        pw.close();
    }
}

二、生日蜡烛

蓝桥杯官网_生日蜡烛

 思路：

设开始生日party时年龄为x，一共举办了n次，则吹熄的蜡烛数为x、x+1、x+2、x+3 ····x+n-1，共nx+n(n-1)/2，枚举x和n使其等于236即可

 答案：

26

代码:

import java.io.IOException;
import java.io.PrintWriter;

public class Main {
    static PrintWriter pw=new PrintWriter(System.out);
    public static void main(String args[]) throws IOException{
        for(int n=1;n<=100;n++){
            for(int x=1;x<=100;x++){
                if(n*(n-1)%2==0 && n*x+n*(n-1)/2==236)
                    pw.println(x);
            }
        }
        pw.close();
    }
}

三、凑算式

蓝桥杯官网_凑算式

该官网题目出错了，原题中A~I代表1~9的数字而不是0~9的数字

 思路：

由6+8/3+952/714=10可知，不能直接利用整数除法下取整来做，将两个分式进行通分
因此将等式转变为  A+(B*(GHI)+C*(DEF))/(C*(GHI))=10 且 (B*(GHI)+C*(DEF))必须是(C*(GHI))的整数倍

答案:

29

代码：

import java.io.IOException;
import java.io.PrintWriter;

public class Main{
    static PrintWriter pw=new PrintWriter(System.out);
    static int N=20;
    static int a[]=new int[N];
    static boolean flag[]=new boolean[N];
    static int res=0;
    public static boolean check(){
        int x1=a[0];
        int x2=a[1];
        int x3=a[2];
        int x4=a[3]*100+a[4]*10+a[5];
        int x5=a[6]*100+a[7]*10+a[8];
        if((x2*x5+x3*x4)%(x3*x5)==0 && x1+(x2*x5+x3*x4)/(x3*x5)==10) return true;
        return false;
    }
    public static void dfs(int u){
        if(u==9){
            if(check()) res++;
            return;
        }
        for(int i=1;i<=9;i++){
            if(!flag[i]){
                flag[i]=true;
                a[u]=i;
                dfs(u+1);
                flag[i]=false;
            }
        }
    }
    public static void main(String args[]) throws IOException{
        dfs(0);
        pw.println(res);
        pw.close();
    }
}

六、方格填数

蓝桥杯官网_方格填数

 思路：

dfs枚举全排列，分别判断每种情况是否相邻
判断是否相邻，即查看这两个位置的数的绝对值的差是否为1

 答案:

1580

代码：

import java.io.IOException;
import java.io.PrintWriter;

public class Main {
    static PrintWriter pw=new PrintWriter(System.out);
    static int N=10;
    static int a[]=new int[N];
    static boolean flag[]=new boolean[N];
    static int res=0;
    public static boolean check(){
        if(Math.abs(a[0]-a[1])==1) return false;
        if(Math.abs(a[0]-a[3])==1) return false;
        if(Math.abs(a[0]-a[4])==1) return false;
        if(Math.abs(a[0]-a[5])==1) return false;
        if(Math.abs(a[1]-a[2])==1) return false;
        if(Math.abs(a[1]-a[4])==1) return false;
        if(Math.abs(a[1]-a[5])==1) return false;
        if(Math.abs(a[1]-a[6])==1) return false;
        if(Math.abs(a[2]-a[5])==1) return false;
        if(Math.abs(a[2]-a[6])==1) return false;
        if(Math.abs(a[3]-a[4])==1) return false;
        if(Math.abs(a[3]-a[7])==1) return false;
        if(Math.abs(a[3]-a[8])==1) return false;
        if(Math.abs(a[4]-a[5])==1) return false;
        if(Math.abs(a[4]-a[7])==1) return false;
        if(Math.abs(a[4]-a[8])==1) return false;
        if(Math.abs(a[4]-a[9])==1) return false;
        if(Math.abs(a[5]-a[6])==1) return false;
        if(Math.abs(a[5]-a[8])==1) return false;
        if(Math.abs(a[5]-a[9])==1) return false;
        if(Math.abs(a[6]-a[9])==1) return false;
        if(Math.abs(a[7]-a[8])==1) return false;
        if(Math.abs(a[8]-a[9])==1) return false;
        return true;
    }
    public static void dfs(int u){
        if(u==10){
            if(check()) res++;
            return;
        }
        for(int i=0;i<=9;i++){
            if(!flag[i]){
                flag[i]=true;
                a[u]=i;
                dfs(u+1);
                flag[i]=false;
            }
        }
    }
    public static void main(String args[]) throws IOException{
        dfs(0);
        pw.println(res);
        pw.close();
    }
}

七、剪邮票

蓝桥杯官网_剪邮票

 思路:

将原题重新进行编码，转换的数的下标如上图所示，便于判断两点是否相连（两个数的绝对值相差1或者5即代表相连）
dfs枚举五个数，共 C_{12}^{5}=792种情况，判断每种情况的五个数字都相连即可
判断五个数字是否相连，利用并查集的思想，若两个数相连，则将其合并，最后判断这五个数是否合并为一堆，若为1则代表这五个数相连

相连的情况，最后合并为一堆，即连通块数量为1

 不相连情况，最后堆数大于1，即连通块数量大于1

答案:

116

 代码:

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Main {
    static PrintWriter pw=new PrintWriter(System.out);
    static int N=20;
    static int b[]={1,2,3,4,6,7,8,9,11,12,13,14};
    static boolean flag[]=new boolean[N];
    static int a[]=new int[N];
    static int c[]=new int[N];
    static int p[]=new int[N];
    static Set<Integer>set=new HashSet<>();
    public static int find(int x){//并查集
        if(p[x]!=x) p[x]=find(p[x]);
        return p[x];
    }
    public static boolean check(int c[]){
        for(int i=0;i<5;i++) p[i]=i;
        for(int i=0;i<5;i++){
            for(int j=i+1;j<5;j++){
                if((find(i)!=find(j)) && (Math.abs(c[i]-c[j])==5 || Math.abs(c[i]-c[j])==1)){
                    p[find(j)]=find(i);//合并
                }
            }
        }
        int res=0;
        for(int i=0;i<5;i++){//查找一共有几堆
            if(p[i]==i) res++;
        }
        return res==1;
    }
    public static void dfs(int u){
        if(u==5){
            c=Arrays.copyOf(a,5);//由于次数是C12 5而不是A12 5,因此不考虑顺序,将这五个数进行排序
            Arrays.sort(c,0,5);
            int x=c[0]*10000+c[1]*1000+c[2]*100+c[3]*10+c[4];
            if(check(c)) set.add(x);
            return;
        }
        for(int i=0;i<b.length;i++){
            if(!flag[i]){
                flag[i]=true;
                a[u]=b[i];
                dfs(u+1);
                a[u]=0;
                flag[i]=false;
            }
        }
    }
    public static void main(String args[]) throws IOException{
        dfs(0);
        pw.println(set.size());
        pw.close();
    }
}

八、四平方和

蓝桥杯官网_四平方和

 思路：

首先想到暴力枚举四层循环，但时间复杂度为0(n^4),不可取，需要进行优化
考虑空间换时间，定义node类，存储c,d,sum,首先枚举c,d,预处理出c,d, c^2+d^2,存储在链表中，按照sum从小到大排序，然后枚举a,b，同时计算n-a*a-b*b的差值x，二分查找链表，若能够找到sum=x，则此时即a,b,c,d即是答案

代码：

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main {
    static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter pw=new PrintWriter(System.out);
    public static int nextInt() throws IOException{
        st.nextToken();
        return (int)st.nval;
    }
    static class node implements Comparable<node>{
        int c,d,sum;
        public node(int c,int d,int sum){
            this.c=c;
            this.d=d;
            this.sum=sum;
        }
        public int compareTo(node p){
            return Integer.compare(sum,p.sum);
        }
    }
    static int n;
    static List<node>list=new ArrayList<>();
    public static void main(String args[]) throws IOException{
        n=nextInt();
        int cnt=0;
        for(int c=0;c*c<=n/2;c++){
            for(int d=c;c*c+d*d<=n;d++){
                list.add(new node(c,d,c*c+d*d));
            }
        }
        Collections.sort(list);
        for(int a=0;a*a<=n/4;a++){
            for(int b=a;a*a+b*b<=n/2;b++){
                int x=n-a*a-b*b;
                int l=0,r=list.size()-1;
                while (l<r){
                    int mid=l+r>>1;
                    if(list.get(mid).sum>=x) r=mid;
                    else l=mid+1;
                }
                if(list.get(r).sum==x){
                    int c=list.get(r).c;
                    int d=list.get(r).d;
                    pw.println(a+" "+b+" "+c+" "+d);
                    pw.close();
                    return;
                }
            }
        }
    }
}

九、取球博弈

蓝桥杯官网_取球博弈

 思路:

递归+记忆化搜索
f[num][me][you]共三维状态，num为当前小球的剩余数，me表示此时我手中球的个数是否为奇数，1表示为奇数，0表示为偶数，you同理；

 代码：

import java.io.*;
import java.util.Arrays;

public class Main{
    static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter pw=new PrintWriter(System.out);
    public static int nextInt() throws IOException{
        st.nextToken();
        return (int)st.nval;
    }
    static int n;
    static int N=1010;
    static int f[][][]=new int[N][2][2];
    static int a[]=new int[3];
    public static int dfs(int num,int me,int you){//num为当前剩余球的个数,me:0代表我有偶数个球,1代表我有奇数个球,you同理
        if(f[num][me][you]!=0) return f[num][me][you];
        if(num<a[0]){//最小的都不够拿
            if((me&1) == (you&1)) return 2;//同奇或同偶,平局
            else if((me&1)==1) return 1;//赢
            return -1;//输
        }
        else{
            boolean nowin=false;
            for(int i=2;i>=0;i--){
                if(num<a[i]) continue;
                int res=dfs(num-a[i],you,(me+a[i])&1);//对方结果
                if(res==-1) return f[num][me][you]=1;
                if(res==2) nowin=true;
            }
            if(nowin) return f[num][me][you]=2;//所有情况都无法取胜的前提下,平局;
            return f[num][me][you]=-1;
        }
    }
    public static void main(String args[]) throws IOException{
        for(int i=0;i<3;i++) a[i]=nextInt();
        Arrays.sort(a);
        for(int i=1;i<=5;i++){
            n=nextInt();
            int res=dfs(n,0,0);
            if(res==1) pw.print("+ ");
            else if(res==-1) pw.print("- ");
            else pw.print("0 ");
        }
        pw.close();
    }
}

十、压缩变换

蓝桥杯官网_压缩变换

 思路：

首先考虑暴力做法，用map来记录每个数即其上一次出现的下标t，若当前数之前从未出现过，则将a[i]变为其相反数；否则，从t+1开始到i-1，将每个数都加入到set中，最终set的大小即是两数中间的种类数，将a[i]=set.size()，最终输出a[i]即可；时间复杂度为0(n^2)，会超时，在蓝桥杯官网上过了四个测试用例（4/8）
利用树状数组进行优化，时间复杂度0（nlogn）,具体详见代码注释

代码一 暴力做法：

import java.io.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Main {
    static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter pw=new PrintWriter(System.out);
    public static int nextInt() throws IOException{
        st.nextToken();
        return (int)st.nval;
    }
    static int n;
    static int N=100010;
    static int a[]=new int[N];
    static Map<Integer,Integer>map=new HashMap<>();
    public static void main(String args[]) throws IOException{
        n=nextInt();
        for(int i=1;i<=n;i++) a[i]=nextInt();
        for(int i=1;i<=n;i++){
            int x=a[i];
            if(map.get(x)==null){//之前未出现过
                pw.print(-a[i]+" ");
            }
            else{
                int t=map.get(x);//上次x出现的位置
                Set<Integer> set=new HashSet<>();
                for(int j=t+1;j<i;j++) set.add(a[j]);
                pw.print(set.size()+" ");
            }
            map.put(x,i);
        }
        pw.close();
    }
}

代码二 树状数组优化

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class Main {
    static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter pw=new PrintWriter(System.out);
    public static int nextInt() throws IOException{
        st.nextToken();
        return (int)st.nval;
    }
    static int n;
    static int N=100010;
    static int a[]=new int[N];
    static int tr[]=new int[N];
    static Map<Integer,Integer>map=new HashMap<>();
    public static int lowbit(int x){
        return x&-x;
    }
    public static void add(int x,int v){
        for(int i=x;i<N;i+=lowbit(i)) tr[i]+=v;
    }
    public static int query(int x){
        int res=0;
        for(int i=x;i>=1;i-=lowbit(i)) res+=tr[i];
        return res;
    }
    public static void main(String args[]) throws IOException{
        n=nextInt();
        for(int i=1;i<=n;i++) a[i]=nextInt();
        for(int i=1;i<=n;i++){
            int x=a[i];
            if(map.get(x)==null){//之前未出现过
                a[i]=-a[i];
                add(i,1);
            }
            else{
                int t=map.get(x);//上次出现的位置
                add(t,-1);
                add(i,1);
                a[i]=query(i-1)-query(t);
            }
            map.put(x,i);
        }
        for(int i=1;i<=n;i++) pw.print(a[i]+" ");
        pw.close();
    }
}

God同学
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2016年 第7届 蓝桥杯 Java B组 省赛解析及总结
upward
08-21 2448
01 煤球数目 找规律 简单计算 02 生日蜡烛 枚举: 1两个年龄 2过生日的次数，等差数列求和的公式 03 凑算式 全排列+check 04 分小组 逻辑 05 抽签递归，搞清楚参数的含义和参数的变化方向 06 方格填数 全排列+check 07**** 剪邮票 全排列(带重复元素的全排列，要用套路全排套路1) +标注(二维数组上标注01) +dfs求连通块数目 08 四平方和 枚举优化(hash缓存) 09*** 取球博弈 典型的博弈框架(带平局) 10****压缩变换 hash查找+标注+区间树
2016年蓝桥杯省赛B组Java真题
小李的博客
09-19 725
1. 煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 2. 生日蜡烛 某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一共吹熄了236根蜡烛。 请问，他从多少岁开始过生日party的？ 请填写他开始过生日party的年
2016年第七届蓝桥杯省赛试题及详解（Java本科A组）
future277809183的专栏
02-09 429
结果填空 (满分3分) 结果填空 (满分5分) 结果填空 (满分9分) 代码填空 (满分11分) 代码填空 (满分13分) 结果填空 (满分15分) 结果填空 (满分19分) 程序设计（满分21分） 程序设计（满分23分） 程序设计（满分31分） 第一题：煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， .... 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意
2015年第六届蓝桥杯省赛 Java A 组真题
Code-CHAN的博客
04-07 143
2015年第六届蓝桥杯省赛 Java A 组真题 第一题 public class Q1 { public static void main(String[] args) { int n = 1543, ans = 0; while (n > 0) { if (n % 2 != 0) { n--; ans++; } n /= 2; } System.out.println(ans); } } 答案：5 第二题 import java.uti
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 446
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 214
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 230
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
2201_76027754的博客
07-15 773
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 472
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 314
手撕七大排序 （三）
【排序算法】—— 归并排序
2302_80105876的博客
07-15 814
归并排序，排序，归并排序非递归，有序数组排序，外排序算法
【C++】B3716分解质因子3 题解_素数筛法_欧拉筛+埃氏筛_算法竞赛
YLCHUP的博客
07-14 704
洛谷B3716题解，一道巧妙的质数筛法变形题，讲解得很详细，适合中等水平学习。快来看ヾ(•ω•`)o
【JavaScript 算法】哈希表：快速查找与存储
Allen-
07-15 779
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
【算法/序列】等差数列&&子序列&&算术序列&&最长对称子串
island1314的博客
07-14 914
子序列：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。该题主要是求其满足等差性质的子数组个数，并且子数组在原数组的相对顺序不能变，并且。长度为3的子序列：（1，2，3）、（1，2，5）、（1，4，5）长度为1的子序列：（1）、（2）、（3）、（4）、（5）长度为2的子序列：长度为2的子序列都是算术子序列。：是数组中的一个连续序列。长度为4的子序列：0。长度为5的子序列：0。
日常练习2
wniuniu_的博客
07-14 229
【代码】日常练习2。
算法面试题五
Chujun123528的博客
07-18 713
深度学习中的优化算法是训练神经网络时用于最小化或最大化某个函数（通常是损失函数或目标函数）的重要工具。这些算法通过迭代更新模型的参数来减少误差，提高模型的性能。以下是几种常用的深度学习优化算法及其解释：
多源字段聚合重塑算法
最新发布
qq_43071699的博客
07-18 261
【代码】多源字段聚合重塑算法。
指针的运算
qq_69383179的博客
07-14 811
这里有关于指针的运算的一些知识
蓝桥杯省赛夺奖攻略：重点知识与历年真题解析
"蓝桥杯备考资料《夺奖宝典》（下）包含了蓝桥杯省赛的历年常考知识点及精炼题目，旨在帮助参赛者准备比赛。资料涵盖数论、组合数学、数学、字符串、图论和计算几何等多个领域的算法问题，并提供了题解代码和相关...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值