蓝桥杯第十一届Java大学B组省赛第二场真题及题解

最新推荐文章于 2024-11-08 11:06:20 发布
最新推荐文章于 2024-11-08 11:06:20 发布
阅读量703 收藏 21
点赞数 20
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 java 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyeahu/article/details/137609795
版权

试题 A: 门牌制作

1711712708375

[题解]


public class Main {
    public static void main(String[] args) {
        int ans = 0;
        for (int i = 1; i <= 2020; i++) {
            String s = i + "";
            for (int j = 0; j < s.length(); j++) {
                if (s.charAt(j) == '2') ans++;
            }
        }
        System.out.println(ans);
    }
}

[答案]

624

试题 B: 寻找 2020

1711714656606

[题解]

直接暴力枚举所有可能性

给定的 txt 文件是个 300 * 300 的矩阵


import java.util.Scanner;

public class Main {
    public static final int N = 310;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[][] num = new int[N][N];
        for (int i = 1; i <= 300; i++) {
            String str = sc.next();
            for (int j = 1; j <= str.length(); j++) {
                num[i][j] = str.charAt(j - 1) - '0';
            }
        }

        int ans = 0;
        for (int i = 1; i <= 300; i++) {
            for (int j = 1; j <= 300; j++) {
                if (i + 3 <= 300 && num[i][j] == 2 && num[i + 1][j] == 0 && num[i + 2][j] == 2 && num[i + 3][j] == 0)
                    ans++;
            }
        }

        for (int i = 1; i <= 300; i++) {
            for (int j = 1; j <= 300; j++) {
                if (j + 3 <= 300 && num[i][j] == 2 && num[i][j + 1] == 0 && num[i][j + 2] == 2 && num[i][j + 3] == 0)
                    ans++;
            }
        }

        for (int i = 1; i <= 300; i++) {
            for (int j = 1; j <= 300; j++) {
                if (i + 3 <= 300 && j + 3 <= 300 && num[i][j] == 2 && num[i + 1][j + 1] == 0 && num[i + 2][j + 2] == 2 && num[i + 3][j + 3] == 0)
                    ans++;
            }
        }
        System.out.println(ans);

    }
}

[答案]

16520

试题 C: 蛇形填数

1711714680022

[题解]

多写几行会发现第 i 行 i 列中的数 = 第 i - 1 行 i - 1 列 + 4 * (i - 1)


public class Main {
    public static void main(String[] args) {
        int ans = 1;
        for (int i = 0; i < 20; i++) {
            ans += 4 * i;
        }
        System.out.println(ans);
    }
}

[答案]

761

试题 D: 七段码

1711714702678

[题解]


import java.util.*;
public class Main {

    public static void main(String[] args) {
        new Main().go();
    }

    static final int N = 8;
    //存储图， 0 表示没有连接
    int[][] G = new int[N][N];

    private void go() {
        G[1][1] = G[1][2] = G[1][6] = 1;
        G[2][2] = G[2][1] = G[2][3] = G[2][7] = 1;
        G[3][3] = G[3][2] = G[3][4] = G[3][7] = 1;
        G[4][4] = G[4][3] = G[4][5] = 1;
        G[5][5] = G[5][4] = G[5][6] = G[5][7] = 1;
        G[6][6] = G[6][1] = G[6][5] = G[6][7] = 1;
        G[7][7] = G[7][2] = G[7][3] = G[7][5] = G[7][6] = 1;
        for (int i = 1; i <= 7; i++) {
            for (int j = 1; j <= 7; j++) {
                cnt = 0;
                String str = "" + i;
                dfs(i, j, str);
            }
        }
        System.out.println(set.size());

    }

    int cnt;
    // 存放实际亮灯情况
    Set<String> set = new HashSet<>();

    private void dfs(int s, int d, String str) {
        if (s == d) {
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String s1 = new String(chars);
            set.add(s1);
            return;
        }
        for (int i = 1; i <= 7; i++) {
            // 可行继续向下寻找路径
            if (G[s][i] != 0 && !str.contains("" + (char)(i + '0'))) {
                str = str + i;
                dfs(i, d, str);
                str = str.substring(0,str.length() - 1);
            }
        }
    }
}

[答案]

80

试题 E: 排序

1711714720717

[题解]

由于冒泡排序最糟糕的情况是，逆序。

所以为了字符串最短就要使得冒泡处于最糟糕的情况。

最糟糕冒泡排序交换次数 n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​, n 为字符串长度

代入得 n = 15 时，需要交换 105 次， n = 14，需要交换 91 次。

则可确定字符串最短长度为 15。

为了使得字典序最短我们取前 15 个字母组成最糟糕冒泡排序的字符串：“onmlkjihgfedcba”, 我们还需交换字母顺序，减少 5 次交换。

由于字典序是从第一个字符开始比较，我们只要使得第一个字符字典序最小即可。

故我们只要将 ‘j’ 移到最前面，其他保持不变，则符合要求。

[答案]

jonmlkihgfedcba

试题 F: 成绩分析

1711714737424

[题解]


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.stream.*;


/**
 * 2020 成绩分析 调用 Java 大数 api 防止数据精度问题导致题目错误
 */
public class Main {
	
    public static void main(String[] args) throws Exception {
        new Main().go();
    }
    
    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
    	br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();
        
        pw.flush();
    }
    
    private int nextInt() throws Exception {
		st.nextToken();
		return (int) st.nval;
	}

    static final int N = 10010;
    int n;
    private void getAns() throws Exception {
      n = nextInt();
      int max = 0;
      int min = 100;
      int sum = 0;
      for (int i = 1; i <= n; i++) {
		int score = nextInt();
		max = Math.max(max, score);
		min = Math.min(min, score);
		sum += score;
      }
      pw.println(max);
      pw.println(min);
      BigDecimal bigDecimalSum = new BigDecimal(sum);
      BigDecimal bigDecimalN = new BigDecimal(n);
      BigDecimal bigDecimalAvg = bigDecimalSum.divide(bigDecimalN, 2, RoundingMode.HALF_UP);
      pw.println(bigDecimalAvg);
    }   
}

试题 G: 单词分析

1711762045481

[题解]


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.stream.*;


/**
 * 2020 单词分析 哈希
 */
public class Main {
	
    public static void main(String[] args) throws Exception {
        new Main().go();
    }
    
    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
    	br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();
        
        pw.flush();
    }
    
    private int nextInt() throws Exception {
		st.nextToken();
		return (int) st.nval;
	}
    
    static final int N = 1010;
    char[] str;
    int[] cnt = new int[26];
    private void getAns() throws Exception {
        String s = br.readLine();
        str = s.toCharArray();
        for(char c : str) {
        	cnt[c - 'a']++;
        }
        int max = 0;
        for(int i : cnt) max = Math.max(max, i);
        for (int i = 0; i < cnt.length; i++) {
			if (max == cnt[i]) {
				pw.println((char)('a' + i));
				pw.println(max);
				break;
			}
		}
    }    
}

试题 H: 数字三角形

1711762079716

[题解]


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.stream.*;


/**
 * 2020 数字三角形 dp
 * 向左下走的次数与向右下走的次数相差不能超过 1，
 * 只是说明最终取得这个点所有左下次数累和与右下次数累和之差不超过 1，
 * 而不是每次走都要与上一次不一样。
 * 最后能走到中间的，则代表左下次数与右下次数之差不超过 1。
 */
public class Main {
	
    public static void main(String[] args) throws Exception {
        new Main().go();
    }
    
    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
    	br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();
        
        pw.flush();
    }
    
    private int nextInt() throws Exception {
		st.nextToken();
		return (int) st.nval;
	}
    
    static final int N = 110;
    int[][] a = new int[N][N];
    int n;
    private void getAns() throws Exception {
    	n = nextInt();
    	for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				a[i][j] = nextInt();
			}
		}
        dp();
        int ans = ((n & 1) == 1 ? f[n][n / 2 + 1] : Math.max(f[n][n / 2], f[n][n / 2 + 1]));
        pw.println(ans);
    }
    
    // f(i,j,k) i, j 代表几行几列
	int[][] f = new int[N][N];
	
    private void dp() {
    	for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				f[i][j] = a[i][j] + Math.max(f[i - 1][j - 1], f[i - 1][j]);
			}
		}	
	}   
}

试题 I: 子串分值和

1711762108713

[题解]


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.stream.*;


/**
 * 2020 子串分值和 dp 贡献法
 * 定义状态 f(i)， 以 i 下标结尾子串的分值和
 * 采用贡献法的方式计算状态转移
 * 每新增一个字符，必然会产生一个只包含本身的子串故肯定产生 1 个贡献值
 * 其次，每新增一个字符对之前 i - 1 个字符包含新增字符的子串产生至多 1 个贡献
 * 当 i - 1 个的字符中没有新增字符相同的字符则会产生 1 个贡献
 * 我们记与新增字符相同的字符最近位置为 pos, 若不存在则记 pos = 0
 * f(i) = f(i - 1) + i - pos - 1 + 1 = f(i - 1) + i - pos 
 */
public class Main {
	
    public static void main(String[] args) throws Exception {
        new Main().go();
    }
    
    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
    	br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();
        
        pw.flush();
    }
    
    private int nextInt() throws Exception {
		st.nextToken();
		return (int) st.nval;
	}
    
    static final int N = (int)1e5 + 10;

    char[] str;
    long[] f = new long[N];
    int[] pos = new int[26];
    
    private void getAns() throws Exception {
        String s = br.readLine();
        int n = s.length();
        str = s.toCharArray();
        long ans = 0;
        for (int i = 1; i <= n; i++) {
			f[i] = f[i - 1] + i - pos[str[i - 1] - 'a'];
			pos[str[i - 1] - 'a'] = i;
			ans += f[i];
		}
        pw.println(ans);
    }   
}

极致贡献法, 相当于对之前算法的空间进行优化


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.stream.*;


/**
 * 2020 子串分值和 贡献法
 * 每新增一个字符，必然会产生一个只包含本身的子串故肯定产生 1 个贡献值
 * 其次，每新增一个字符对之前 i - 1 个字符包含新增字符的子串产生至多 1 个贡献
 * 当 i - 1 个的字符中没有新增字符相同的字符则会产生 1 个贡献
 * 我们记与新增字符相同的字符最近位置为 prePos, 若不存在则记 prePos = 0
 * 我们对后面 n - i + 1 个字符(包含新增字符)都会产生 i - prePos 的贡献
 * 所有每新增一个字符对结果产生的总贡献为 (i - prePos) * (n - i + 1)
 */
public class Main {
	
    public static void main(String[] args) throws Exception {
        new Main().go();
    }
    
    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
    	br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();
        
        pw.flush();
    }
    
    
    static final int N = (int)1e5 + 10;

    char[] str;
    // 起始不存在位置为 0
    int[] prePos = new int[26];
    
    private void getAns() throws Exception {
        String s = br.readLine();
        int n = s.length();
        s = " " + s;
        str = s.toCharArray(); 
        long ans = 0;
        for (int i = 1; i <= n; i++) {
        	int index = str[i] - 'a';
        	ans += (long)(i - prePos[index]) * (n + 1 - i);
        	prePos[index] = i;
		}
        pw.println(ans);
    }    
}

试题 J: 装饰珠

1711762147928

[题解]


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

/**
 * 2020 装饰珠 dp
 * 分析题意，装备数是固定的且实际相关的也只是装饰孔，故我们只要存放装饰孔的数据即可
 * 即问题可变换为经典的分组背包问题
 * 记 t 为装饰珠可增加价值最大数量
 * 1.题意中一个类别的装饰珠数量可以为任意，但超过 t，就没有意义，即没必要枚举大于 t 的值
 * 2.为了能够快速定位到一个类别的装饰珠放的位置，应该使得装饰孔按照等级升序排列
 * 3.由于装饰珠镶嵌是有条件的，装饰孔按等级排序可以方便我们不用多次判断是否符合条件，只要判断两个端点的装饰孔是否满足条件即可
 * 4.同时大等级的 f(j) 更新可能会用到小等级的 f(j),即应该使得装饰珠也按等级升序排列
 */
public class Main {

    public static void main(String[] args) throws Exception {
        new Main().go();
    }

    static BufferedReader br;
    static StreamTokenizer st;
    static PrintWriter pw;

    private void go() throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));
        st = new StreamTokenizer(br);
        pw = new PrintWriter(new OutputStreamWriter(System.out));

        getAns();

        pw.flush();
    }

    private int nextInt() throws Exception {
        st.nextToken();
        return (int) st.nval;
    }

    // 每件装备最多装饰孔数量
    static final int N = 310;
    // 装饰珠最多种类数量
    static final int M = (int)1e4 + 10;
    // 存放装备装饰孔的情况
    int[] a = new int[N];
    // 存放装饰珠情况
    B[] b = new B[M];
    // 状态：最大价值量
    long[] f = new long[N];
    // 装备孔数量
    int n;
    // 装饰珠种类数量
    int m;
    private void getAns() throws Exception {
        // 读到装备装饰孔情况
        for (int i = 1; i <= 6; i++) {
            int tmp = nextInt();
            for(int j = 1; j <= tmp; j++) {
                n++;
                a[n] = nextInt();
            }
        }
        // 读到装饰珠情况
        // 装饰珠种类数量
        m = nextInt();
        for (int i = 1; i <= m; i++) {
            // 装饰珠等级
            int L = nextInt();
            // 装饰珠可增加价值最大数量
            int P = nextInt();
            int[] w = new int[P + 1];
            for(int j = 1; j <= P; j++) {
                w[j] = nextInt();
            }
            b[i] = new B(L, P, w);
        }
        // 主要 Java api 提供的排序区间是左闭右开的
        Arrays.sort(a, 1, n + 1);
        Arrays.sort(b,1,m + 1, Comparator.comparing(B::getS));
        dp();
        pw.println(f[n]);
    }

    private void dp() {
        for(int i = 1; i <= m; i++) {
            for (int j = n; j >= 1; j--) {
                for (int k = 1; k <= b[i].t; k++) {
                    // 找到同一等级装饰珠起始位置
                    int p = j - k + 1;
                    // 满足可镶嵌条件， 都不满足就表示不镶嵌
                    if (a[j] >= b[i].s && p >= 1 && a[p] >= b[i].s) {
                        f[j] = Math.max(f[j], f[p - 1] + b[i].w[k]);
                    }
                }
            }
        }

    }

    // 装饰珠相关数据
    class B {
        int s, t; // s 装饰珠等级，t 装饰珠可增加价值最大数量
        int[] w; // 不同装饰珠对应的价值量

        public B(int s, int t, int[] w) {
            this.s = s;
            this.t = t;
            this.w = w;
        }
        public int getS() {
            return s;
        }
    }
}

以上综合各位大佬提供给的思路和我自己的思路，自己写出的题解。

菜旺学习
关注
专栏目录
蓝桥杯第十二届Java大学生B组省赛真题及题解
whyeahu的博客
03-28 1240
蓝桥杯第十二届大学 B 组 Java 省赛真题及题解
2020 第十一届蓝桥杯大赛软件类省赛第二场Java 大学 B 组 题面和部分题解
nuoyanli的博客
10-19 1297
A: 门牌制作 题面： 思路： 暴力遍历，1-2020的数字，然后判断每一位，计数。 代码： import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int ans = 0; for (int i = 1; i <= 2020; i++) { int j = i; while (j
2023年第十四届蓝桥杯JavaB组省赛真题（题目+全部完整题解）
热门推荐
冷兮雪的博客
04-08 3万+
A、阶乘求和【问题描述】令S= 1!+ 2!+ 3!...，求S的末尾9位数字。提示：答案首位不为0。
蓝桥杯第十四届Java大学生B组省赛真题及题解
whyeahu的博客
04-10 485
蓝桥杯第十四届Java大学生B组省赛真题及题解
蓝桥杯第十三届Java大学生B组省赛真题及题解
whyeahu的博客
04-10 862
蓝桥杯第十三届Java大学生B组省赛真题及题解
2020第十一届蓝桥杯第二场省赛JAVA A组真题解析（带源码及解析）
王跃坤的博客
04-14 4436
蓝桥杯历年真题及解析. 目录：蓝桥杯历年真题及解析.A：门牌制作（难度：★）题目：分析：代码：B：既约分数（难度：★★）题目：分析：代码：C：蛇形填数（难度：★★）题目：分析：代码：D：七段码（难度：★★★）题目：分析：代码：E：平面分割（难度：★★★★）题目：分析：代码：F：成绩分析（难度：★）题目：分析：代码：G：回文日期（难度：★★★）题目：分析：代码：H：子串分值（难度：★★★★）题目：分析：代码：I：荒岛探测（难度：★★★★★）题目：分析：代码：J：字串排序（难度：★★★★★）题目：分析：代码：算
2021年第十二届蓝桥杯省赛Java B组真题及题解
计算机程序定制、毕业项目
04-03 1130
2021年第十二届蓝桥杯省赛Java B组真题及详细题解
2023年第十四届蓝桥杯JavaB组省赛真题及全部解析（上）
2301_80035594的博客
06-28 803
2023年第十四届蓝桥杯Java B组省赛全部解析（上）。
2024年十五届蓝桥杯省赛大学B组真题（Java残缺版）
2302_76207485的博客
04-30 6795
2024年十五届蓝桥杯省赛大学B组真题（Java完整版）题解
2021第十二届蓝桥杯Python组省赛第一场（真题&题解）
weixin_46044901的博客
05-13 6195
十二届蓝桥杯Python组省赛试题及解析 A题：卡片 B题：直线 C题：货物摆放 D题：路径 E题：回路计数 F题：时间显示 G题：杨辉三角形 H题：左孩子右孩子 I题：异或数列 J题：括号序号 先把省赛试题分享出来，再慢慢完善题解 我的感悟：相对于C++组跟Java组来说，Python组的竞争可能相对较小，省赛能得奖的几率很大。这次省赛，在学校老师的建议下上了Python组的车，没想到最后竟然在省一区找到了自己的名字（省赛时自己是算法小白）。省赛已经过去了快一个月，离国赛（6月5号）也不远了，现在正在
2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结【第2场省赛 2020.10.17】
upward
10-31 1万+
一、试题 A: 门牌制作——答案：641 解法一：x % 10 == 2 解法二：双重for循环+字符数组 二、试题 B: 寻找 2020——答案：16520 三、试题 C: 蛇形填数——答案：761 解法一：规律推公式 (n-1)(2n-1)+n 解法二：手工计算（写满两页A4演草纸） 四、试题 D: 七段码——答案：80 五、试题 E: 排序——jonmlkihgfedcba 六、试题 F: 成绩分析 七、试题 G: 单词分析 八、试题 H: 数字三角形 九、试题 I: 子串分值 十、试题 J: 装饰珠
第十五届蓝桥杯软件赛C/C++大学A组个人省赛题解
2301_78234743的博客
04-30 1733
** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @从三月初开始零碎的投递，到三月底开始海投，三月的时候面试的机会其实很少，到4月初面试机会才逐渐多了起。如题，具体地址是渝北区重庆涉外商务区B4幢附近，这附近有什么好的房源吗，以及有合租的小伙伴吗，预计五。#字节跳动内推#我的内推码：JNG3GB9我的内推码：JNG3GB9我的内推码：JNG3GB9我的内。
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
03-17 2717
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
第十二届蓝桥杯JavaB组省赛（题目及AC题解）
03-07 1979
题一：ASCII码 【问题描述】 已知大写字母 A 的 ASCII 码为 65，请问大写字母 L 的 ASCII 码是多少？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。 答案： 简单，不做解释 76 题二：卡片–暴力循环 小蓝有很多数字卡片，每张卡片上都是数字 0 到 9。 小蓝准备用这些卡片来拼一些数，他想从 1 开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其它数了。 小蓝想知道自己能从
蓝桥杯 Python组-神奇闹钟（datetime库）
AuRoRamth的博客
11-05 1229
传送门： 0神奇闹钟 - 蓝桥云课​​​​​​小蓝发现了一个神奇的闹钟，从纪元时间（1970 年 11 日 00：00：00）开始，每经过 x 分钟，这个闹钟便会触发一次闹铃 (纪元时间也会响铃)。这引起了小蓝的兴趣，他想要好好研究下这个闹钟。对于给出的任意一个格式为 уууу-MM-ddHH:mm:ss 的时间，小蓝想要知道在这个时间点之前 (包含这个时间点) 的最近的一次闹铃时间是哪个时间?注意，你不必考虑时区问题。输入格式输入的第一行包含一个整数 T，表示每次输入包含 T 组数据。接下来依次描述
蓝桥杯 懒洋洋字符串--字符串读入
最新发布
2401_82736456的博客
11-08 318
题目 代码 #include <iostream> using namespace std; int main() { int n; cin>>n; char s[210][4]; int ans=0; for(int i=0;i<n;i++){ scanf("%s",s[i]); } for(int i=0;i<n;i++){ char a=s[i][0]; char b=s[i][
蓝桥杯第二十场小白入门赛
m0_73924943的博客
10-26 987
用数学思维来分析：设k*k区间中分别有a行，b列被选中，即长度为n的字符串中有a个1，长度为m的字符串中有b个1。最后看了看别人的和我相似的思路，才发现原来自己思路有漏洞，我把可能情况分两部分，一是两个目标地点在同一侧，二是不在同一侧。查看了测试用例后，我才明白，可能茶壶容量远小于一杯茶的容量，也就是说，你要倒满一杯茶，需要接好几次水壶，而我的代码中循环一次res最多也加一。后果就是，对于这类测试用例，我的循环结束了，我的sum还远远小于0，还没加成正值。我的思路代码：（但我不知道哪有错误）
蓝桥杯 区间移位--二分、枚举
2401_82736456的博客
11-04 1177
每个区间的两个端点分别为 a 和 b，要求找到一个最小的移动距离 m，使得所有区间通过向左或向右移动不超过 m 的距离后能够连续覆盖 [0, 10000] 这个区间。由于答案可能包含 0.5，所以将输入的区间扩大了两倍来处理，最终结果再除以2。使用二分查找来确定最小的移动距离 m。首先定义搜索的上下界，然后不断缩小范围直到找到满足条件的最小 m 值。使用变量 k来追踪当前已覆盖的最右端点。如果当前区间的移动后能与 k 连接，则更新 k 的值。
蓝桥杯第21场小白入门赛补题
2302_79372568的博客
11-05 1055
【代码】蓝桥杯第21场小白入门赛补题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值