【2017年蓝桥杯Java-B组省赛题解】

置顶 已于 2022-05-15 15:33:42 修改
阅读量1w 收藏 12
点赞数 1
分类专栏： 算法修炼 文章标签： 蓝桥杯 java 职场和发展
于 2022-02-12 22:57:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxeron/article/details/122894915
版权
这篇博客回顾了2017年Java编程竞赛中的一些难题，包括购物单的计算器问题，纸牌三角形的排列计算，承压计算涉及的杨辉三角应用，以及魔方状态的复杂性分析。此外，还提到了日期问题的Calendar类模拟，包子凑数的最大公约数计算，分巧克力的二分查找算法，以及区间和的前缀和优化技巧。这些题目展示了编程竞赛中的多元算法思维和问题解决策略。
摘要由CSDN通过智能技术生成

2017Java-B组省赛

一、购物单（计算器）

标题： 购物单

    小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。

    这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
    小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
    现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。

    取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
    你的任务是计算出，小明最少需要取多少现金。

以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
****     180.90       88折
****      10.25       65折
****      56.14        9折
****     104.65        9折
****     100.30       88折
****     297.15        半价
****      26.75       65折
****     130.62        半价
****     240.28       58折
****     270.62        8折
****     115.87       88折
****     247.34       95折
****      73.21        9折
****     101.00        半价
****      79.54        半价
****     278.44        7折
****     199.26        半价
****      12.97        9折
****     166.30       78折
****     125.50       58折
****      84.98        9折
****     113.35       68折
****     166.57        半价
****      42.56        9折
****      81.90       95折
****     131.78        8折
****     255.89       78折
****     109.17        9折
****     146.69       68折
****     139.33       65折
****     141.16       78折
****     154.74        8折
****      59.42        8折
****      85.44       68折
****     293.70       88折
****     261.79       65折
****      11.30       88折
****     268.27       58折
****     128.29       88折
****     251.03        8折
****     208.39       75折
****     128.88       75折
****      62.06        9折
****     225.87       75折
****      12.89       75折
****      34.28       75折
****      62.16       58折
****     129.12        半价
****     218.37        半价
****     289.69        8折
--------------------

需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。

请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。


特别提醒：不许携带计算器入场，也不能打开手机。

用电脑自带计算器计算就行，注意取款机只能取100的倍数。
答案：5200

二、纸牌三角形（模拟、数学思维去重）

标题：纸牌三角形

A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。

      A
     9 6
    4   8
   3 7 5 2

这样的排法可能会有很多。

如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？

请你计算并提交该数字。

注意：需要提交的是一个整数，不要提交任何多余内容。

在这里插入图片描述

import java.util.*;

public class Main {
    static LinkedList<Integer> tmp = new LinkedList<>();
    static int ans = 0;
    static int[] vis = new int[10];
    public static void main(String[] args) {
        dfs();
        System.out.println(ans / 6);
    }
    static void dfs() {
        if (tmp.size() == 9) {
            if (tmp.get(0) + tmp.get(1) + tmp.get(2) + tmp.get(3) ==
            tmp.get(3) + tmp.get(4) + tmp.get(5) + tmp.get(6) && tmp.get(3) + tmp.get(4) + tmp.get(5) + tmp.get(6) ==
            tmp.get(6) + tmp.get(7) + tmp.get(8) + tmp.get(0)) {
                System.out.println(tmp);
                ans++;
            }
            return;
        }
        for (int i = 1; i <= 9; i++) {
            if (vis[i] == 1) {
                continue;
            }
            vis[i] = 1;
            tmp.add(i);
            dfs();
            vis[i] = 0;
            tmp.removeLast();
        }
    }
}

在这里插入图片描述
题目中已知，镜像、旋转属于同一种，旋转有三种情况，由旋转之后的镜像又有三种，所以同一个等边三角形会被计算6次，但实际有效的是1次，所以用全排列求得结果还要 / 6。
答案：144

三、承压计算（杨辉三角、数学思维）

标题：承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。

                             7 
                            5 8 
                           7 8 8 
                          9 2 7 2 
                         8 1 4 9 1 
                        8 1 8 8 4 1 
                       7 9 6 1 4 5 4 
                      5 6 5 5 6 9 5 6 
                     5 5 4 7 9 3 5 5 1 
                    7 5 7 9 7 4 7 3 3 1 
                   4 6 4 5 5 8 8 3 2 4 3 
                  1 1 3 3 1 6 6 5 5 4 4 2 
                 9 9 9 2 1 9 1 9 2 9 5 7 9 
                4 3 3 7 7 9 3 6 1 3 8 8 3 7 
               3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
              8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
             8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
            2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 
           7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 
          9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 
         5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 
        6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 
       2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 
      7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 
     1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 
    2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 
   7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 
  7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 
 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X 

其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。

工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

对于某一层 i，它这一层有 i 个数字，当 j = 1时：weight[i][j] += weight[i - 1][j] / 2；当 j = i 时：weight[i][j] += weight[i - 1][j - 1] / 2（就是在每一层的左右两边的情况）。其余处于中间的情况，weight[i][j] = weight[i][j] + ( weight[i - 1][j - 1] + weight[i - 1][j] ) / 2。这样一直迭代到第30层，注意，题目中说的计量单位很小，我们不知道计量单位，只能通过迭代的结果中的最小值，用最小示数 / 最小值，来确定计量单位。再找到最大值，用计量单位 * 最大值即得到最后答案。

package Chapter_5;

import java.util.*;
/*
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
 */
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double[][] arr = new double[30][30];
        for (int i = 0; i < 29; i++) {
            for (int j = 0; j <= i; j++) {
                arr[i][j] = scan.nextDouble();
            }
        }
        // 开始推导
        for (int i = 1; i < 30; i++) {
            for (int j = 0; j <= i; j++) {
                if (j == 0) {
                    arr[i][j] += arr[i - 1][j] / 2;
                } else if (j == i) {
                    arr[i][j] += arr[i - 1][j - 1] / 2;
                } else {
                    arr[i][j] += (arr[i - 1][j - 1] + arr[i - 1][j]) / 2;
                }
            }
        }
        double min = arr[29][0];
        double max = arr[29][0];
        for (int i = 0; i < 30; i++) {
            if (arr[29][i] < min) {
                min = arr[29][i];
            }
            if (arr[29][i] > max) {
                max = arr[29][i];
            }
        }
        System.out.println(max * (2086458231 / min));
        // 7.2665192664E10
    }
}

答案：72665192664

四、魔方状态（做不来）

标题：魔方状态

二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。

小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：

前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色

请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。

如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。

请提交表示状态数的整数，不要填写任何多余内容或说明文字。

在这里插入图片描述
这道题过于困难…不适合我，比赛的时候应该不会花时间去做。
补充一道2017年javaA组的第一题：

标题：迷宫

X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。

房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。

X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！

开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。

迷宫地图如下：
------------
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
------------

请你计算一下，最后，有多少玩家会走出迷宫? 
而不是在里边兜圈子。

请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。

如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：
p1.png

直接DFS搜索，注意不需要回溯，出去了就ans++。

import java.util.*;

public class Main {
    static char[][] map = new char[11][11];
    static int[][] vis = new int[11][11];
    static LinkedList<Character> tmp = new LinkedList<>();
    static int ans = 0;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        for (int i = 0; i < 10; i++) {
            map[i] = scan.next().toCharArray();
            System.out.println(map[i]);
        }
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                vis = new int[11][11];
                tmp = new LinkedList<>();
                tmp.add(map[i][j]);
                dfs(map[i][j], i, j);
            }
        }
        System.out.println(ans);
    }
    static void dfs(char next, int i, int j) {
        int tmpx;
        int tmpy;
        if (next == 'D') {
            tmpx = i + 1;
            tmpy = j;
        } else if (next == 'U') {
            tmpx = i - 1;
            tmpy = j;
        } else if (next == 'L') {
            tmpx = i;
            tmpy = j - 1;
        } else {
            tmpx = i;
            tmpy = j + 1;
        }
        if (tmpx < 0 || tmpy < 0 || tmpx >= 10 || tmpy >= 10) {
            ans++;
            System.out.println("*****");
            System.out.println(tmp);
            return;
        }
        if (vis[tmpx][tmpy] == 1) {
            System.out.println("=====");
            System.out.println(tmp);
            return;
        }
        vis[tmpx][tmpy] = 1;
        tmp.add(map[tmpx][tmpy]);
        dfs(map[tmpx][tmpy], tmpx, tmpy);
    }
}

答案：31
还是这种小题目适合我 x）。

五、六、程序填空题

七、日期问题（非常细节的模拟、Calendar类）

在这里插入图片描述
这道题的题目描述，到处都是关键点，首先告诉只有三种情况：年月日、月日年、日月年，又告诉答案必须要从早到晚排序，注意输入格式、输出格式里面的“----”不是要输入、输出的东西！！

这道题涉及到某年某月的月份天数的确定，可以使用Calendar类实现，实现如下：

	 //生成Calendar对象
     Calendar cal = Calendar.getInstance();
     // 获取这个月到底有几天
     cal.set(year_num, month, 0);
     int monty_day = cal.get(Calendar.DATE);

注意月份从0开始，一月份应该传入0。如果日期为0，则自动跳转到上一个月的最后一天，例如：cal.set(2000, 2, 0)设置的是三月份的上一月份的最后一天，也就是2月份的最后一天，再用cal.get(Calendar.DATE)就可以得到上一个月的天数。

对于输入02/03/04，可以使用String的split进行分割，在遍历三种情况时，我们可以只修改读取的下标而不用修改遍历的代码。还需要注意答案要去重 + 排序，代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String[] imps = new String[];
        String imp = scan.next();
        imps = imp.split("/");
        // 只有三种情况：年月日、月日年、日月年
        // 年月日 012
        // 月日年 201
        // 日月年 210
        int[][] num = new int[][] {{0,1,2},{2,0,1},{2,1,0}};
        // 答案要去重
        Set<String> ans_set = new HashSet<>();
        List<String> ans_list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            String ans = "";
            // 保证a一直拿到的都是年，b一直拿到的是月，c一直拿到的是日
            String year = imps[num[i][0]];
            String month = imps[num[i][1]];
            String day = imps[num[i][2]];
            int a = Integer.parseInt(year);
            int b = Integer.parseInt(month);
            int c = Integer.parseInt(day);
            int year_num = 0;
            if (a >= 60) {
                ans = ans + "19" + year;
                year_num = 1900 + a;
            } else {
                ans = ans + "20" + year;
                year_num = 2000 + a;
            }
            if (b >= 1 && b <= 12) {
                ans = ans + "-" + month;
            } else {
                continue;
            }
            Calendar cal = Calendar.getInstance();
            // 获取这个月到底有几天
            cal.set(year_num, b, 0);
            int monty_day = cal.get(Calendar.DATE);
            if (c >= 1 && c <= monty_day) {
                ans = ans + "-" + day;
            } else {
                continue;
            }
            // 答案去重
            if (ans_set.contains(ans)) {
                continue;
            } else {
                ans_set.add(ans);
                ans_list.add(ans);
            }
        }
        // 从小到大排序日期
        Collections.sort(ans_list);
        for (int i = 0; i < ans_list.size(); i++) {
            System.out.println(ans_list.get(i));
        }
    }
}

八、包子凑数（最大公约数）

在这里插入图片描述
在这里插入图片描述
首先考虑只有一个包子，那么如果个数是1，那么都可以凑出来，不是1，那都凑不出来的数=INF。回归到本质，这道题其实是让找几个数的gcd，如果gcd = 1则不可凑出的数是有限个（可以用dp数组找），如果gcd != 1，说明这些数都是某个数的倍数，被拿来拿去相加，也还是某个数的倍数，始终有数凑不出来，所以也是INF。

import java.util.*;

public class Main {
    static int gcd(int a, int b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        // 有多少数目的包子是凑不出来的
        int[] bz = new int[n];
        int flag = 0;
        boolean[] dp = new boolean[10001];
        dp[0] = true;
        for (int i = 0; i < n; i++) {
            bz[i] = scan.nextInt();
            dp[bz[i]] = true;
        }
        if (n == 1 && bz[0] != 1) {
            System.out.println("INF");
        } else if (n == 1 && bz[0] == 1) {
            System.out.println(0);
        } else {
            int tmp = bz[0];
            for (int i = 1; i < n; i++) {
                tmp = gcd(tmp, bz[i]);
            }
            // 最大公约数为 1 那么都可以凑出来
            if (tmp == 1) {
                flag = 1;
            }
            // 如果最大公约数不是 1，说明所有能够凑成的数都是某个数的倍数，INF
            if (flag == 0) {
                System.out.println("INF");
            } else {
                int ans = 0;
                for (int i = 0; i < n; i++) {
                    for (int j = 1; j <= 10000; j++) {
                        if (dp[j]) {
                            continue;
                        }
                        if (bz[i] <= j) {
                            dp[j] = dp[j - bz[i]];
                        }
                    }
                }
                for (int i = 1; i <= 10000; i++) {
                    if (dp[i]) {
                        continue;
                    }
                    ans++;
                }
                System.out.println(ans);
            }
        }
    }
}

九、分巧克力（模拟、二分）

在这里插入图片描述

在这里插入图片描述
模拟分巧克力的过程，一块巧克力能够分成的正方形数目 = (h / a) * (w / a)，a是每块巧克力的边长，我们要保证正方形数目 >= k的情况下，a最大，本质是遍历1 - max所有的可能边长，遇到这种遍历找满足某种条件的值时，很容易就能想到用二分来加速。

import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        int[] h = new int[n];
        int[] w = new int[n];
        int max = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            h[i] = scan.nextInt();
            w[i] = scan.nextInt();
            if (h[i] > max) {
                max = h[i];
            }
            if (w[i] > max) {
                max = w[i];
            }
        }
        int left = 1;
        int right = max;
        int mid;
        int ans = 0;
        while (left <= right) {
            mid = left + (right - left) / 2;
            int cnt = 0;
            for (int i = 0; i < n; i++) {
                cnt += (h[i] / mid) * (w[i] / mid);
            }
            if (cnt >= k) {
                if (mid > ans) {
                    ans = mid;
                }
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        System.out.println(ans);
    }
}

※十、k倍区间（前缀和）

在这里插入图片描述
需要用到前缀和，外加一些加速技巧（等价转换），单纯的前缀和会超时。

前缀和数组：preSum[i] = A0 + … + Ai-1

i - j的区间和 = preSum[j + 1] - preSum[i] = Ai + … + A[j]

(preSum[j + 1] - preSum[i]) % k == 0 等价于：preSum[j + 1] % k == preSum[i] % k ，我们只要统计preSum[i + 1] % k相同的个数。

注意，这里忽略了单独一个前缀和能被 k 整除的情况，所以在最后还要统计加回来。换句话说，这里只探讨两个前缀和构成的区间和的情况，没有考虑一个前缀和（从0到自身）的和的情况。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        int[] num = new int[n];
        long ans = 0;
        for (int i = 0; i < n; i++) {
            num[i] = scan.nextInt();
        }
        // preSum[i] = A0 + ... + Ai-1
        // i - j的区间和 = preSum[j + 1] - preSum[i] = Ai + ... + A[j]
        // (preSum[j + 1] - preSum[i]) % k == 0
        // 所以，preSum[j + 1] % k == preSum[i] % k
        // 前缀和数组
        int[] preSum = new int[n + 1];
        for (int i = 1; i < n + 1; i++) {
            preSum[i] = (preSum[i - 1] + num[i - 1]) % k;
        }
        long[] cnt = new long[n + 1];
        // 只需要统计preSum % k相同的个数即可
        for (int i = 1; i < n + 1; i++) {
            ans += cnt[preSum[i]];
            cnt[preSum[i]]++;
        }
        // 前面找的都是preSum[i] % k == preSum[j] % k的情况
        // 没有单独考虑前缀和的情况
        // 别忘了有前缀和直接能被k整除的情况
        System.out.println(ans + cnt[0]);	
		
		// 也可以通过将cnt[0]初值赋为1来保证获取所有的区间可能
    }
}

2017年的蓝桥杯，在填空题方面有难度，但编程题难度较小，都是可以拿分的，但是一开始做填空题一定要稳住心态，你难我难都难。

@u@
关注
专栏目录
2017_第八届蓝桥杯省赛题解 JavaB组
qq_41695452的博客
03-17 429
一、 标题： 购物单 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供100元面额的纸币。小明想尽可能少...
蓝桥杯2017年第八届C/C++ B组省赛习题题解
lihua777的博客
03-17 7044
蓝桥杯2017年第八届C/C++ B组省赛习题题解
蓝桥杯省赛2017年 JavaB组 题目+答案
Peanut的博客
02-15 1860
第一题 标题： 购物单 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供100元面额的纸币。小明想尽...
2017 蓝桥杯 JavaB组 省赛
Jitwxs
04-09 2319
2018年4月1日，备战2018蓝桥杯省赛！ 转载请注明出处https://blog.csdn.net/yuanlaijike/article/details/69802431 1. 购物单 2. 纸牌三角形 3. 承压计算 4. 魔方状态 5. 取数位 6. 最大公共子串 7. 日期问题 8. 包子凑数 9. 分巧克力 10. k倍区间 1. 购物...
【Java】【第八届蓝桥杯】【试题】【无答案】
安逸风声
04-08 2564
1、 标题： 购物单     小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。     这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。     小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。     现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
2017蓝桥杯javaB组
Xiao_Jin_Ling的博客
03-15 359
一、购物单 1.题目： 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。 你的任务是计算出，小明最少需要取多少现金。 以下是让人头疼的购物单，为了保护隐私，物
蓝桥杯-蓝桥杯竞赛练习题-详细题解-题解源码
最新发布
01-17
在“蓝桥杯_蓝桥杯竞赛练习题_详细题解_题解源码”这个压缩包中，包含了丰富的资源，帮助参赛者理解和解决竞赛中的实际问题。首先，详细的题解部分是关键，它通常会为每一道竞赛题目提供清晰的思路分析，包括问题的...
蓝桥杯2015-2019软件C/C++/JAVA/G/A/B/C组省赛国赛真题+评测数据+解析
07-29
自2015年以来，该赛事已经连续多年举办，涵盖了C/C++、JAVA、G（图形化编程）、A（初中组）、B（高中组）、C（大学组）等多个级别的比赛。这些竞赛分为省赛和国赛，难度逐级递增，为参赛者提供了丰富的学习和挑战...
第十三届蓝桥杯C++ B组省赛(题解+个人心得)
处_的博客
04-12 1万+
初赛心得 2022/4/9，本人于大一下初次参加面向各大高校的编程竞赛，在参赛选拔时，对算法的了解仅为皮毛，学习acwing算法基础课，仅能掌握快速幂、前缀和等初级算法。经过大约一个月的学习，初步了解二分、前缀和、位运算、STL库(观看数组实现视频，无法独立完成)、暴搜、简单并查集、Kruskal(克鲁斯卡尔)求最短路、快速幂、简单博弈论(Nim游戏)，知道DP(仅观看推导视频，跟抄代码，从未自己实现)，会做简单贪心，并能够做出简单推导，学习了微扰法证明国王游戏(可在算法竞赛进阶指南中查阅)。 ...
2017第八届蓝桥杯C/C++ B组省赛题解
热门推荐
YzlCoder的记事本
04-08 11万+
2017年第八届蓝桥杯C/C++ B组省赛题解
蓝桥杯2017JAVA_B省赛真题详解
菜得真实的博客
03-18 1136
第一题：购物单 题目描述 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供100元面额的纸币。小明想尽可...
第八届蓝桥杯java B组国赛题目
stay hungry ! stay foolish!
05-02 2104
第八届蓝桥杯java B组国赛题目第一题：平方十位数由0~9这10个数字不重复、不遗漏，可以组成很多10位数字。这其中也有很多恰好是平方数（是某个数的平方）。比如：1026753849，就是其中最小的一个平方数。请你找出其中最大的一个平方数是多少？注意：你需要提交的是一个10位数字，不要填写任何多余内容。直接全排求，我得到的答案取最大的：9814072356import java.util.Has...
蓝桥杯 2017年省赛
chen_chen_chen_的博客
10-16 323
main.c #include <stc15.h> #include "sys.h" bit flag500ms=0; int hour=0x23; int minute=0x59; int second=0x50; int hour0=0x00; int minute0=0x00;int second0=0x00; int time_flag[]={0,0,0,0,0,0}; bit flag_back=0;bit flag_led=0; void main() { All_In
蓝桥杯2017年第八届JavaB组---整理
zzzbeauty的博客
03-23 783
第一题： 标题： 购物单 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 ...
蓝桥杯2017-Java B组省赛真题
dashujuxinxing的博客
03-10 332
蓝桥杯2017年 Java B组省赛 真题（题目+答案）
2017年 第八届蓝桥杯 Java B组真题整理（附答案）
mcp3128
03-22 1万+
1.购物单    小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。    这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。    小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。    现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。    取款机只能提供100元面额的...
2017年 第8届 蓝桥杯 Java B组 省赛真题详解及总结
RGHLY21的博客
03-15 576
令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。给定一个长度为N的数列，A1, A2, ... AN，如果其中一段连续的子序列Ai, Ai+1, ... Aj(i
2017蓝桥杯省赛JavaB组部分题目及解答
Hoshizola的博客
06-16 229
第二题 标题：纸牌三角形 A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。 下图就是一种排法（如有对齐问题，参看p1.png）。 这样的排法可能会有很多。 如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？ public class _02纸牌三角形 { static int ans; public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5, 6, 7
2017第八届蓝桥杯C/C++ B组省赛个人代码
weixin_30588827的博客
04-08 200
第一题 标题： 购物单 小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。 这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。 小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。 现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。 取款机只能提供1...
蓝桥杯Java决赛历年题解：算法与编程挑战
该资源是一份包含2013年至2018年期间蓝桥杯Java B组决赛的题目解析和代码文本。蓝桥杯是中国的一项著名信息技术竞赛，主要考察参赛者的算法设计与编程能力。这份文档详细地展示了三个题目及其解决方案： 1. 猜灯谜 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@u@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值