2023年第十四届蓝桥杯JavaB组省赛真题（题目+全部完整题解）_蓝桥杯题目

最新推荐文章于 2024-05-25 11:47:49 发布

2401_84164595

最新推荐文章于 2024-05-25 11:47:49 发布

阅读量755

点赞数 9

分类专栏： 2024年程序员学习文章标签：蓝桥杯职场和发展

本文链接：https://blog.csdn.net/2401_84164595/article/details/137836980

版权

2024年程序员学习专栏收录该内容

99 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

Ⅰ、题目解读

一看到三个2023的巨大数字，我想大家应该都人都麻了。但是我想说这是官方的骗术，因为题目说要求末尾的9位数，其实我想告诉大家当加到40多的阶乘时，这个阶乘和后面的9位数就不会发生改变了。

Ⅱ、代码


public class Main {
    public static void main(String[] args) {
        long start=1;
        String s="202320232023";
        long end= Long.parseLong(s);
        long sum=0;
        long cj=1;
        while (start<=end){
            cj*=start;
            cj%=1000000000;
            sum+=cj;
            sum%=1000000000;
            start++;
            if (start>40)
                System.out.println(sum);
        }
        System.out.println(sum);
    }
}

看运行
20940313
420940313
420940313
420940313
420940313
420940313
420940313
...
这是因为40的阶乘之后后面 9位数都是0，所以阶乘之和末尾9位数不会再发生改变！

B、幸运数字

【问题描述】

哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整数。例如 126
是十进制下的一个哈沙德数，因为
(126)
10
mod
(1+2+6) = 0
；
126 也是八进制下的哈沙德数，因为 (126)
10
= (176)
8
，
(126)
10
mod
(1 + 7 + 6) = 0
；同时 126
也是
16
进制下的哈沙德数，因为
(126)
10
= (7
e
)
16
，
(126)
10
mod
(7 +
e
) = 0
。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为哈沙德数，那么这个数字就是幸运数字，第 1
至第
10
个幸运数字的十进制表示为：1
,
2
,
4
,
6
,
8
,
40
,
48
,
72
,
120
,
126
. . .
。现在他想知道第
2023
个幸运数字是多少？你只需要告诉小蓝这个整数的十进制表示即可。

Ⅰ、题目解读

这题就是考察大家的进制转换，数据量也不大。直接看代码吧！

Ⅱ、代码

public class {
    public static void main(String[] args) {
        int j=0;
        for (int i=1;i<10000000;i++){
            if (BaseConversion(i)){
                j++;
                if (j==2023){
                    System.out.println(i);//215040
                    break;
                }
            }
        }
    }
    public static boolean BaseConversion(int n){
        //十进制
        int sum=0;
        int x=n;
        while (x!=0){
            sum+=(x%10);
            x/=10;
        }
        if (n%sum!=0)
            return false;
        //二进制
        sum=0;
        x=n;
        while (x!=0){
            sum+=(x%2);
            x/=2;
        }
        if (n%sum!=0)
            return false;
        //八进制
        sum=0;
        x=n;
        while (x!=0){
            sum+=(x%8);
            x/=8;
        }
        if (n%sum!=0)
            return false;
        //十六进制
        int[] arr={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        sum=0;
        x=n;
        while (x!=0){
            sum+=(arr[x%16]);
            x/=16;
        }
        if (n%sum!=0)
            return false;
        return true;
    }
}

C: 数组分割（时间限制: 1.0s 内存限制: 512.0MB）

时间限制
1.0s
内存限制
512.0MB

本题总分：
10
分

【问题描述】

小蓝有一个长度为
N
的数组
A
= [
A
0
,
A
1
, . . . ,
A
N
−
1
]
。现在小蓝想要从
A
对应的数组下标所构成的集合 I

{
0
,
1
,
2
, . . . ,
N
−
1
}
中找出一个子集
R
1
，那么
R
1在 I
中的补集为
R
2
。记
S
1

∑
r
∈
R
1
A
r
，
S
2

∑
r
∈
R
2
A
r，我们要求
S
1
和
S
2
均为偶数，请问在这种情况下共有多少种不同的 R
1。当
R1 或
R
2
为空集时我们将
S
1
或
S
2
视为
0。

【输入格式】

第一行一个整数
T
，表示有
T
组数据。接下来输入 T
组数据，每组数据包含两行：第一行一个整数
N
，表示数组
A
的长度；第二行输入
N
个整数从左至右依次为
A
0
,
A
1
, . . . ,
A
N
−
1
，相邻元素之间用空格分隔。

【输出格式】

对于每组数据，输出一行，包含一个整数表示答案，答案可能会很大，你

需要将答案对
1000000007
进行取模后输出。

【样例输入】
2
2
6 6
2
1 6
【样例输出】
4

【样例说明】

对于第一组数据，答案为
4
。（注意：大括号内的数字表示元素在数组中的下标。）

R
1

{
0
}
,
R
2

{
1
}
；此时
S
1

A
0
= 6
为偶数
,
S
2

A
1
= 6
为偶数。

R
1

{
1
}
,
R
2

{
0
}
；此时
S
1

A
1
= 6
为偶数
,
S
2

A
0
= 6
为偶数。

R
1

{
0
,
1
}
,
R
2

{}
；此时
S
1

A
0
+
A
1
= 12
为偶数
,
S
2
= 0
为偶数。

R
1

{}
,
R
2

{
0
,
1
}
；此时
S
1
= 0
为偶数
,
S
2

A
0
+
A
1
= 12
为偶数。

对于第二组数据，无论怎么选择，都不满足条件，所以答案为
0
。

【评测用例规模与约定】

对于
20
%
的评测用例，
1
≤
N
≤
10
。

对于
40
%
的评测用例，
1
≤
N
≤
10
2
。

对于
100
%
的评测用例，
1
≤
T
≤
10
,
1
≤
N
≤
10
3
,
0
≤
A
i
≤
10
9
。

Ⅰ、解题思路

要求分割两个子集，其中一个可以为空集，且两个集合为偶数，所有第一步判断集合的总和是否为偶数，如果不为偶数则直接判定为 0 个否则再进行深度收搜判断 (暴力超时)

也可以利用奇数个数与偶数个数的排列组合实现，将两个奇数拼接为一个偶数，判断无重复的奇数拼接情况，与偶数个数相加，递推排列组合公式 (正解)

优化排列组合，会发现是高精度算法设 x 为偶数个数， y 为奇数个数ans = pow(x + (y == 0 ? 0 : y - 1)) % mod 算法标签：递推，找规律，贪心

注意事项:
x + (y == 0 ? 0 : y - 1), 奇数为0情况

Ⅱ、代码

//排列组合递推公式
 
import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    public static final BigInteger MOD = new BigInteger("1000000007");
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int T = scan.nextInt();
        while (T-- > 0){
            int n = scan.nextInt();
            int[] a = new int[n];
            long x = 0, y = 0; // x 记录偶数， y 记录奇数
            for(int i = 0; i < n; i++){
                a[i] = scan.nextInt() % 2;
                if(a[i] == 0){
                    x++;
                }else {
                    y++;
                }
            }
            if(y % 2 == 1){ // 奇数个数为奇，没有一个条件成立
                System.out.println(0);
                continue;
            }
            x = x + (y == 0 ? 0 : y - 1);  // 两个奇数组合为一个偶数，排除重复情况
            BigInteger ans = new BigInteger("2");
            BigInteger dp = new BigInteger("1");
            // C(n,m) = P(n,m) / P(m,m) = n! / m! * (n - m)!
            // 转移递推公式 dp = (dp * (x, x-1, x-2, ... , n) / (1, 2, 3, ... , n))
            for(long i = 1, j = x; i < x; i++, j--){ // 排列组合无顺序 C
                BigInteger u = new BigInteger(String.valueOf(j));
                BigInteger v = new BigInteger(String.valueOf(i));
                dp = dp.multiply(u).divide(v);
                ans = ans.add(dp);
            }
            System.out.println(ans.mod(MOD));
        }
    }
}

优化高精度

import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    public static final BigInteger MOD = new BigInteger("1000000007");
    public static final BigInteger TWO = new BigInteger("2");
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int T = scan.nextInt();
        while (T-- > 0) {
            int n = scan.nextInt();
            int x = 0, y = 0; // x 记录偶数， y 记录奇数
            for (int i = 0; i < n; i++) {
                int a = scan.nextInt() % 2;
                if (a == 0) {
                    x++;
                } else {
                    y++;
                }
            }
            if (y % 2 == 1) {
                System.out.println(0);
            }else{
                System.out.println(TWO.pow(x + (y == 0 ? 0 : y - 1)).mod(MOD));
            }
        }
    }
}

D、矩形总面积（时间限制: 1.0s 内存限制: 512.0MB）

【问题描述】

平面上有个两个矩形
R
1
和
R
2
，它们各边都与坐标轴平行。设
(
x
1
,
y
1
)
和 (x
2
,
y
2
)
依次是
R
1
的左下角和右上角坐标，
(
x
3
,
y
3
)
和
(
x
4
,
y
4
)
依次是
R
2
的左下角和右上角坐标，请你计算 R
1
和
R
2
的总面积是多少？

注意：如果
R
1
和
R
2
有重叠区域，重叠区域的面积只计算一次。

【输入格式】

输入只有一行，包含
8
个整数，依次是：
x
1
，
y
1
，
x
2
，
y
2
，
x
3
，
y
3
，
x
4
和
y
4
。

【输出格式】

一个整数，代表答案。

【样例输入】
2 1 7 4 5 3 8 6
【样例输出】
22
【样例说明】

样例中的两个矩形如图所示：

【评测用例规模与约定】

对于
20
%
的数据，
R
1
和
R
2
没有重叠区域。

对于
20
%
的数据，其中一个矩形完全在另一个矩形内部。

对于
50
%
的数据，所有坐标的取值范围是
[0
, 10³
]
。

对于
100
%
的数据，所有坐标的取值范围是
[0
, 10⁵
]

Ⅰ、题目解读

这题有两种解法，自己数组去求，但是可能数据量过大会爆栈。第二种就是公式直接求解，这时求两个矩形相交的面积改怎么求？

矩形相交要使条件成立，即min(x2,x4)-max(x1,x3)>=0 且min(y2,y4)-max(y1,y3)>=0
如果条件成立，则相交矩形面积为：(min(x2,x4)-max(x1,x3))* (min(y2,y4)-max(y1,y3))

Ⅱ、代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x1 = sc.nextInt();
        int y1 = sc.nextInt();
        int x2 = sc.nextInt();
        int y2 = sc.nextInt();
        int x3 = sc.nextInt();
        int y3 = sc.nextInt();
        int x4 = sc.nextInt();
        int y4 = sc.nextInt();
        long area1 = (long) (x2 - x1) * (y2 - y1); // 计算第一个矩形的面积
        long area2 = (long) (x4 - x3) * (y4 - y3); // 计算第二个矩形的面积
        long overlapArea=0;
        long l = Math.min(x2, x4) - Math.max(x1, x3);
        long w= Math.min(y2,y4)-Math.max(y1,y3);
        if (l >=0&&w >=0){
            overlapArea= l * w;
        }
        long Area = area1 + area2 - overlapArea; // 总面积
        System.out.println(Area); // 输出总面积
    }
}

E、蜗牛（时间限制: 1.0s 内存限制: 512.0MB）

【问题描述】

这天，一只蜗牛来到了二维坐标系的原点。在 x
轴上长有
n
根竹竿。它们平行于
y
轴，底部纵坐标为
0
，横坐标分别为 x
1
,
x
2
, …,
x
n
。竹竿的高度均为无限高，宽度可忽略。蜗牛想要从原点走到第
n
个竹竿的底部也就是坐标
(
x
n
,
0)
。它只能在
x
轴上或者竹竿上爬行，在
x
轴

上爬行速度为
1
单位每秒；由于受到引力影响，蜗牛在竹竿上向上和向下爬行的速度分别为 0
.
7
单位每秒和
1
.
3
单位每秒。为了快速到达目的地，它施展了魔法，在第 i
和
i

1
根竹竿之间建立了传送门（0 <
i
<
n
），如果蜗牛位于第
i
根竹竿的高度为
a
i
的位置
(
x
i
,
a
i
)
，就可以瞬间到达第 i
1
根竹竿的高度为
b
i
+1
的位置
(
x
i
+1
,
b
i
+1
)，
请计算蜗牛最少需要多少秒才能到达目的地。

【输入格式】

输入共
1 +
n
行，第一行为一个正整数
n
；

第二行为
n
个正整数
x
1
,
x
2
, . . . ,
x
n
；

后面
n
−
1
行，每行两个正整数
a
i
,
b
i
+1
。

【输出格式】

输出共一行，一个浮点数表示答案（
四舍五入保留两位小数
）。

【样例输入】
3
1 10 11
1 1
2 1
【样例输出】
4.20
【样例说明】

蜗牛路线：

(0
,
0)
→
(1
,
0)
→
(1
,
1)
→
(10
,
1)
→
(10
,
0)
→
(11
,
0)
，花费时间为
1 +1/
0.7

0 + 1/1 .3
1
≈
4
.
20

【评测用例规模与约定】

对于
20
%
的数据，保证
n
≤
15
；

对于
100
%
的数据，保证
n
≤ 10⁵
，a
i
,
b
i
≤ 10⁴
，x
i
≤ 10⁹
。

Ⅰ、题目解读

dp[i][j] 表示蜗牛走到第 i 根杆子的最短用时，j 表示状态。
j = 0 : 走到杆子底部
j = 1 ：走到杆子的传送门处
P.S.由于只与前一个杆子状态有关，其实用两个变量就行，用二维数组便于理解
时间复杂度: O(n)

Ⅱ、代码

import java.io.*;
import java.util.*;
public class Main{
    static int maxn = 200005,n,m;
    static long INF = (long)2e18,ans = 0,mod = (int)1e9+7;
    static Scanner sc = new Scanner (System.in);
    static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer st  =new StreamTokenizer(bf);
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[]args) throws IOException{
        int T = 1;
        //T = Integer.parseInt(S());
        while(T-->0) solve();
        pw.flush();
    }
    static final int I() throws IOException {
        st.nextToken();
        return (int)st.nval;
    }
    static void solve() throws IOException{
        n = I();
        long x[] = new long [n+1];
        for(int i=1;i<=n;i++) x[i] = I();
        int []a = new int [n+1];
        int []b = new int [n+1];
        for(int i=1;i<n;i++) {
            a[i] = I();b[i] = I();
        }
        double dp[][] = new double[n+1][2];
        dp[1][0] = x[1]; //底端最小用时
        dp[1][1] = x[1] + a[1] / 0.7;  //传送门用时
        for(int i=2; i<=n ; i++) {
            dp[i][0] = Math.min(dp[i-1][0]+x[i]-x[i-1], dp[i-1][1] + b[i-1]/1.3);
            dp[i][1] = Math.min(dp[i][0] + a[i] / 0.7, dp[i-1][1] + ((b[i-1]>a[i])?(b[i-1]-a[i])/1.3: (a[i]-b[i-1])/0.7));
        }
        pw.printf("%.2f",dp[n][0]);
    }
}

F、合并区域（时间限制: 2.0s 内存限制: 512.0MB）

【问题描述】

小蓝在玩一款种地游戏。现在他被分配给了两块大小均为
N
×
N
的正方形区域。这两块区域都按照 N
×
N
的规格进行了均等划分，划分成了若干块面积相同的小区域，其中每块小区域要么是岩石，要么就是土壤，在垂直或者水平方向上相邻的土壤可以组成一块土地。现在小蓝想要对这两块区域沿着边缘进行合并，他想知道合并以后可以得到的最大的一块土地的面积是多少（土地的面积就是土地中土壤小区域的块数）？在进行合并时，小区域之间必须对齐。可以在两块方形区域的任何一条边上进行合并，可以对两块方形区域进行 90
度、
180
度、
270
度、
360
度的旋转，但不可以进行上下或左右翻转，并且两块方形区域不可以发生重叠。

【输入格式】

第一行一个整数
N
表示区域大小。接下来 N
行表示第一块区域，每行
N
个值为
0
或
1
的整数，相邻的整数之间用空格进行分隔。值为 0
表示这块小区域是岩石，值为
1
表示这块小区域是土壤。再接下来 N
行表示第二块区域，每行
N
个值为
0
或
1
的整数，相邻的整数之间用空格进行分隔。值为 0
表示这块小区域是岩石，值为
1
表示这块小区域是土壤。

【输出格式】

一个整数表示将两块区域合并之后可以产生的最大的土地面积。

【样例输入】
4
0 1 1 0
1 0 1 1
1 0 1 0
1 1 1 0
0 0 1 0
0 1 1 0
1 0 0 0
1 1 1 1
【样例输出】
15
【样例说明】

第一张图展示了样例中的两块区域的布局。第二张图展示了其中一种最佳

的合并方式，此时最大的土地面积为
15
。

【评测用例规模与约定】

对于
30
%
的数据，
1
≤
N
≤
5
。

对于
60
%
的数据，
1
≤
N
≤
15
。

对于
100
%
的数据，
1
≤
N
≤
50
。

Ⅰ、题目解读

题目会给你两块土地，你可以进行两块土地的“缝合”，求最大的连续的土地。

最大土地有三种情况

①、左右连接成一块最大的土地

②、单独一边中间是最大的土地

③、因为另一块土地的连接而导致原本不连接的土地也连接成新的土地（这种情况是我没想到的）

我只想到了前面两种情况，如果要算上第三种情况的话就应该直接使用暴力求解（毕竟数据量并不是很大），不断拼接，求最大连续的土地。我的代码也只是符合前面两种情况，有正确代码还请大佬给出。万分感谢。

Ⅱ、代码


import java.awt.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

public class Main {
    static class Point{
        int x,y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[][] arr1=new int[n+2][n+2];//第一个矩阵
        int[][] arr2=new int[n+2][n+2];//第二个矩阵
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++){
                arr1[i][j]=sc.nextInt();
            }
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++){
                arr2[i][j]=sc.nextInt();
            }
        int max=0;
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++){
                if (arr1[i][j]==1){
                    length(arr1,i,j);
                    List<Point> list=new ArrayList<>(set);
                    for (Point p:list)
                        arr1[p.x][p.y]=sum;
                    max=Math.max(max,sum);//防止矩阵里面是最大的
                    sum=0;
                    set.clear();
                }
            }
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++){
                if (arr2[i][j]==1){
                    length(arr2,i,j);
                    List<Point> list=new ArrayList<>(set);
                    for (Point p:list)
                        arr2[p.x][p.y]=sum;
                    max=Math.max(max,sum);//防止矩阵里面是最大的
                    sum=0;
                    set.clear();
                }
            }
        int l=0;
        int r=0;
        //求四边的最大值然后拼接
        //两行
        for (int i=1;i<=n;i+=(n-1))
            for (int j=1;j<=n;j++){
                l=Math.max(l,arr1[i][j]);
                r=Math.max(r,arr2[i][j]);
            }
        //两列
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j+=(n-1)){
                l=Math.max(l,arr1[i][j]);
                r=Math.max(r,arr2[i][j]);
            }
        max=Math.max(max,l+r);
        System.out.println(max);
    }
    static int sum=0;
    static HashSet<Point> set=new HashSet<>();
    public static void length(int[][] arr, int i, int j){
        sum++;
        arr[i][j]=0;
        Point p=new Point(i,j);
        set.add(p);
        if (arr[i-1][j]==1)
            length(arr,i-1,j);
        if (arr[i+1][j]==1)
            length(arr,i+1,j);
        if (arr[i][j-1]==1)
            length(arr,i,j-1);
        if (arr[i][j+1]==1)
            length(arr,i,j+1);
    }
}

G、买二赠一（时间限制: 1.0s 内存限制: 512.0MB）

【问题描述】

某商场有
N
件商品，其中第
i
件的价格是
A
i
。现在该商场正在进行
“
买二赠一”
的优惠活动，具体规则是：每购买 2
件商品，假设其中较便宜的价格是
P
（如果两件商品价格一样，

则
P
等于其中一件商品的价格），就可以从剩余商品中任选一件价格不超过
**P /2
的商品，免费获得这一件商品。可以通过反复购买 2
件商品来获得多件免费商品，但是每件商品只能被购买或免费获得一次。小明想知道如果要拿下所有商品（包含购买和免费获得），至少要花费多少钱？

【输入格式】

第一行包含一个整数
N
。

第二行包含
N
个整数，代表
A
1
,
A
2
,
A
3
,
. . .
，
A
N

【输出格式】

输出一个整数，代表答案。

【样例输入】
7
1 4 2 8 5 7 1
【样例输出】
25
【样例说明】

小明可以先购买价格
4
和
8
的商品，免费获得一件价格为
1
的商品；再后

买价格为

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

static int sum=0;
static HashSet<Point> set=new HashSet<>();
public static void length(int[][] arr, int i, int j){
    sum++;
    arr[i][j]=0;
    Point p=new Point(i,j);
    set.add(p);
    if (arr[i-1][j]==1)
        length(arr,i-1,j);
    if (arr[i+1][j]==1)
        length(arr,i+1,j);
    if (arr[i][j-1]==1)
        length(arr,i,j-1);
    if (arr[i][j+1]==1)
        length(arr,i,j+1);
}

}


###  G、买二赠一（时间限制: 1.0s 内存限制: 512.0MB）



> 
> 
> **【问题描述】** 
> 
> 
> 某商场有 
> *N* 
> 件商品，其中第 
> *i* 
> 件的价格是 
> *A*
> *i*
> 。现在该商场正在进行 
> “
> 买二 赠一” 
> 的优惠活动，具体规则是： 每购买 2 
> 件商品，假设其中较便宜的价格是 
> *P*
> （如果两件商品价格一样， 
> 
> 
> 则 
> *P* 
> 等于其中一件商品的价格），就可以从剩余商品中任选一件价格不超过
> ***P /*2**
>  的商品，免费获得这一件商品。可以通过反复购买 2 
> 件商品来获得多件免费商 品，但是每件商品只能被购买或免费获得一次。 小明想知道如果要拿下所有商品（包含购买和免费获得），至少要花费多少钱？ 
> 
> 
> 
> **【输入格式】** 
> 
> 
> 第一行包含一个整数 
> *N*
> 。 
> 
> 
> 第二行包含 
> *N* 
> 个整数，代表 
> *A*
> 1
> , 
> *A*
> 2
> , 
> *A*
> 3
> , 
> . . . 
> ，
> *A*
> *N*
> 
> 
> 
> 
> **【输出格式】** 
> 
> 
> 输出一个整数，代表答案。 
> 
> 
> 
> **【样例输入】** 
> 
> 
> 
> ```
> 7
> 1 4 2 8 5 7 1
> ```
> 
> **【样例输出】** 
> 
> 
> 
> ```
> 25
> ```
> 
> **【样例说明】** 
> 
> 
> 
> 小明可以先购买价格 
> 4 
> 和 
> 8 
> 的商品，免费获得一件价格为 
> 1 
> 的商品；再后 
> 
> 
> 买价格为 


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-W9dOnn0Q-1713266873837)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

2401_84164595

关注

9
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
2023年第十四届蓝桥杯JavaB组省赛真题（题目+全部完整题解）_蓝桥杯题目

的规格进行了均等划分，划分成了若干块面积相同的小区域，其中每块小区域要么是岩石，要么就是土壤，在垂直或者水平方向上相邻的土壤可以组成一块土地。要求分割两个子集，其中一个可以为空集，且两个集合为偶数，所有第一步判断集合的总和是否为偶数，如果不为偶数则直接判定为 0 个否则再进行深度收搜判断 (暴力超时)一看到三个2023的巨大数字，我想大家应该都人都麻了。也可以利用奇数个数与偶数个数的排列组合实现，将两个奇数拼接为一个偶数，判断无重复的奇数拼接情况，与偶数个数相加，递推排列组合公式 (正解)
复制链接

扫一扫