第十六届蓝桥杯复盘

最新推荐文章于 2025-05-20 13:57:14 发布
最新推荐文章于 2025-05-20 13:57:14 发布
阅读量1k 收藏 26
点赞数 20
文章标签： 蓝桥杯 java 算法 竞赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42828342/article/details/148070984
版权

文章目录


省赛过去一段时间了，现在复盘下，省赛报完名后一直没准备所以没打算参赛，直到比赛前两天才决定参加，赛前两天匆匆忙忙下载安装了比赛要用的编译器eclipse，当时连编译和运行怎么操作都不知道，平时用的都是idea，就简单熟悉了下输入输出就去比赛了，比赛那天天还没亮，早早出发就去赛点了，赛后也不知ac了多少，结果出来省一等奖进入国赛，这是第一次参加java赛道的，可以说完全没准备，能进国赛靠的是大学打比赛时的基础和运气好，不过大学参加的是cpp组别的，编程语言不一样，但算法思想感觉还是通用的，国赛不打算去参加了，这段时间日夜颠倒，打算出去玩几天缓缓，先去爬个衡山。
在这里插入图片描述

1.数位倍数

【问题描述】
 请问在 1 至 202504（含）中，有多少个数的各个数位之和是 5 的整数倍。例如：5、19、8025 都是这样的数。
 
思路：统计每个数字的数位总和，判断是否5的倍数进行累加。

代码

import java.util.*;

public class Main {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }
    public static void main(String[] args){
        int ans = 0;
        for (int i = 1; i <= 202504; i++) {
            int x = i;
            int cnt = 0;
            while (x != 0) {
                cnt += x % 10;
                x /= 10;
            }
            if (cnt % 5 == 0) {
                ans++;
            }
        }
        out.println(ans);
        out.flush();
        out.close();
    }
}

答案：40500

2.IPv6

【问题描述】
    小蓝最近在学习网络工程相关的知识。他最近学习到，IPv6 地址本质上是一个 128 位的二进制数，而字符串形式的 IPv6 地址是由被冒号分开的八段 16 进制数组成的，例如，下面每行是一个字符串形式的 IPv6 地址:

0000:0000:0000:0000:0000:0000:0000:0000
0000:0001:0000:0000:0000:0001:0000:0000
0000:0001:00ab:0000:0023:0000:0a00:0e00
0000:0000:00ab:0000:000a:0001:0a00:0e00
0000:0000:00ab:0000:0000:0001:0a00:0e00

其中，每一段最长 4 位，且每一段的前导零都可以去掉（如果 4 位都为 0 需要写成 0）。
另外，IPv6 地址还可以将其中相邻的值为 0 的段合并压缩起来，用两个冒号来表示，不过只能压缩一段。
例如上述地址最短的压缩后的形式分别为

::
0:1::1:0:0
0:1:ab:23:0:a00:e00
::ab:0:a:1:a00:e00
0:0:ab::1:a00:e00

小蓝想知道，所有 IPv6 地址的最短压缩形式的长度的和为多少？由于答案很大（甚至超过了 128 位二进制整数的范围），请填写答案时填写这个总和除以10^9+7的余数。
    
思路： dfs+组合数学，先通过dfs 生成段长度组合，每个段的长度a[i]可取0-4，再计算每段的种类数15×16^(len-1)（15表示非 0 首字符数，16^(len-1)为后面字符数），IPv6码总种类数等于所有段种类数的乘积，然后再计算IPV6码压缩后长度=不压缩前长度-压缩的0序列长度，最终将所有情况的长度进行累加。

代码

import java.io.*;

public class Main{
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }
    private static final int MOD = 1000000007;
    private static final int N = 8;
    private static int[] a = new int[N + 1];
    private static long[] fact = new long[5];
    private static long ans = 0;

    public static void main(String[] args) {
        // 初始化16的幂次数组
        fact[0] = 1;
        for (int i = 1; i < 5; i++) {
            fact[i] = fact[i - 1] * 16 % MOD;
        }

        dfs(1);
        System.out.println(ans);
    }


    //dfs生成所有可能的段长度组合
    private static void dfs(int x) {
        if (x == N + 1) {
            // 计算当前组合的总种类数和长度
            long sum = 1;
            for (int i = 1; i <= N; i++) {
                int len = a[i];
                if (len != 0) {
                    // 计算当前段的种类数：(16-1) * 16^(len-1)
                    sum = sum * fact[len - 1] % MOD;
                    sum = sum * 15 % MOD;
                }
            }
            // 计算当前组合的长度
            int currentLength = getLength();
            sum = sum * currentLength % MOD;
            ans = (ans + sum) % MOD;
            return;
        }
        // 枚举当前段的长度（0-4）
        for (int i = 0; i <= 4; i++) {
            a[x] = i;
            dfs(x + 1);
        }
    }


    //计算当前段组合压缩后的IPv6码长度
    private static int getLength() {
        int len = 0; 
        for (int i = 1; i <= N; i++) {
            if (a[i] == 0) {
                len++; // 0段计为1个字符
            } else {
                len += a[i]; // 非0段计为实际长度
            }
        }
        len += 7; 

        int maxCompress = 0;
        int left = -1; // 连续0段的左边界
        for (int right = 1; right <= N; right++) {
            if (a[right] == 0) {
                if (left == -1) {
                    left = right; 
                }
                // 计算当前连续0段的可压缩长度
                int currentCompress;
                if (right == N) { 
                    if (left == 1) { // 全0压缩
                        currentCompress = 2 * (right - left) - 1;
                    } else {
                        currentCompress = 2 * (right - left);
                    }
                } else if (left == 1) {
                    currentCompress = 2 * (right - left);
                } else { // 中间位置的连续0段
                    currentCompress = 2 * (right - left) + 1;
                }
                maxCompress = Math.max(maxCompress, currentCompress);
            } else {
                left = -1; // 遇到非0段，重置左边界
            }
        }
        return len - maxCompress; // 总长度减去最大压缩长度
    }
}

答案：905307083

3.变换数组

【问题描述】
    输入一个数组 a ，包含有 n 个元素 a1,a2,…,an。对这个数组进行 m 次变换，每次变换会将数组 a 中的每个元素 ai 转换为 ai · bitCount(ai)。其中 bitCount(x) 表示数字 x 的二进制表示中 1 出现的次数，例如 bitCount(3)=2，因为 3 的二进制表示为 11，其中 1 出现了两次。
    请输出变换之后的数组内容。
【输入格式】
    输入的第一行包含一个正整数 n ，表示数组 a 中的元素个数。
    第二行包含 n 个整数 a1,a2,…,an，相邻整数之间使用一个空格分隔。
    第三行包含一个整数 m，表示变换次数。
【输出格式】
    输出一行，包含 n 个整数，相邻整数之间使用一个空格分隔，表示变换之后得到的数组 a。
【样例输入】

2
5 7
2

【样例输出】

20 63

思路：计算每个元素对应二进制中1的个数，进行相乘即可。

代码

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

public class Main {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }

    static final int N = 1010;
    static int n, m;
    static int[] a = new int[N];

    // 计算数字二进制中1的个数
    static int count(int x) {
        int cnt = 0;
        while (x != 0) {
            cnt += x % 2;
            x /= 2;
        }
        return cnt;
    }

    public static void main(String[] args) {
        n = Int();
        for (int i = 1; i <= n; i++) {
            a[i] = Int();
        }

        m = Int();
        while (m-- > 0) {
            for (int i = 1; i <= n; i++) {
                a[i] *= count(a[i]);
            }
        }

        for (int i = 1; i <= n; i++) {
            out.print(a[i] + " ");
        }

        out.flush();
        out.close();
    }
}

4.最大数字

【问题描述】
我们有 n 个连续的整数 1,2,3,…,n，可以自由排列它们的顺序。
然后，我们把这些数字转换成二进制表示，按照排列顺序拼接形成一个新的二进制数。
我们的目标是让这个二进制数的值最大，并输出这个二进制对应的十进制表示。
【输入格式】
    输入一行包含一个正整数 n 。
【输出格式】
    输出一行包含一个整数表示答案。
【样例输入】

3

【样例输出】

30

【样例说明】
1 的二进制为 1；2 的二进制为 10；3 的二进制为 11；其组成的最大的二进制数字为 11110，对应的十进制数字为 30。

思路：自定义排序+大数运算，将1 − n 所有数的二进制放入集合后进行排序，然后对排序后的二进制字符串从后往前进行运算转换成10进制。

代码

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

public class Main {
  private static StreamTokenizer st =
      new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

  private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  private static PrintWriter out =
      new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

  private static int Int() {
    try {
      st.nextToken();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    return (int) st.nval;
  }

  private static Long Lon() {
    try {
      st.nextToken();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    return (long) st.nval;
  }

  private static Double Dou() {
    try {
      st.nextToken();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    return st.nval;
  }

  private static String Line() {
    String s = "";
    try {
      s = br.readLine();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    return s;
  }

  public static void main(String[] args) {
    int n = Int();
    List<String> list = new ArrayList<>();
    for (int i = 1; i <= n; ++i) {
      list.add(itos(i));
    }
    Collections.sort(
        list,
        new Comparator<String>() {
          @Override
          public int compare(String o1, String o2) {
            return (o1 + o2).compareTo(o2 + o1) > 0 ? 1 : -1;
          }
        });
    StringBuilder sb = new StringBuilder();
    for (int i = list.size() - 1; i >= 0; --i) {
      sb.append(list.get(i));
    }
    BigInteger sum = new BigInteger("0");
    BigInteger d = new BigInteger("1");
    int len = sb.length();
    for (int i = len - 1; i >= 0; --i) {
      if (sb.charAt(i) == '1') {
        sum = sum.add(d);
      }
      d = d.multiply(new BigInteger("2"));
    }
    out.println(sum);
    out.flush();
    out.close();
  }

  public static String itos(int n) {
    StringBuilder sb = new StringBuilder();
    while (n != 0) {
      sb.append(n % 2);
      n /= 2;
    }
    return sb.reverse().toString();
  }
}

5.小说

【问题描述】

小蓝是一位网络小说家。现在他正在撰写一部新的推理小说，这部小说有 n 个不同的人物。

小说的每一章都有以下三种情节的一种：

A 发现 B 不知道真相。
A 发现 B 知道真相。
A 知道了真相。

为了保证读者的协调和新鲜感，小蓝的小说还要满足以下要求：

“B 发现 A 不知道真相”不能在 “A 知道了真相”后。
“B 发现 A 知道真相”不能在 “A 知道了真相”前。
“B 发现 A 不知道真相”不能在 “B 发现 A 知道真相”后。
相邻的两章情节类型不同，例如如果第一章是 A 发现 B 不知道真相那么第二章就不能是 C 发现 D 不知道真相。
完全相同的情节不能出现两次。

现在小蓝希望知道，他最多能写多少章。
输入的第一行包含一个正整数 n，表示小说人数。
输入

2

输出

6

思路：对于 n 个角色，当 n=1 时，最多可写章节数为为 1；当 n≥2 时，答案为2n^2−3n+4.

分为以下几种情况：
相邻角色：假设角色甲刚知真相，下一个知真相的是角色乙
情况1：除乙外的n−1个角色发现乙不知道真相（共n−1次）
情况2：除甲外的n−1个角色发现甲知道真相（共n−1次）
每对相邻角色有2(n−1)种可能，共n−1对相邻角色，总共有2(n−1)2个情节。
知真相的情况：
情况3：每个角色知道真相对应1个情节，共n个情节
边界处理：
情况4
第一个角色知真相前：只能有情况1
最后一个角色知真相后：只能有情况2，所以边界总共2个情节，最终2n^2−3n+4

代码

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

public class Test2 {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }

    public static void main(String[] args) {
        long n= Lon();
        if(n==1){
           out.println(1);
        }
        else{
            out.println(2*n*n-3*n+4);
        }
        out.flush();
        out.close();
    }
}

6.01串

【问题描述】
    给定一个由 0,1,2,3…的二进制表示拼接而成的长度无限的 01 串。其前若干位形如 011011100101110111… 。请求出这个串的前 x 位里有多少个 1 。
【输入格式】
    输入的第一行包含一个正整数 x 。
【输出格式】
    输出一行包含一个整数表示答案。
【样例输入】

7

【样例输出】

5

思路：分段统计+位运算，将自然数（0,1,2,3,…）的二进制拼接而成的01 串分为两段处理，分别是前面的完整段和后面的不完整段，先计算有多少个完整的自然数段被完全包含在前x位中，再处理剩余部分，对最后一个不完整的自然数段，统计其中前mod位内的1的个数。

代码

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

public class Test2 {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }

    public static void main(String[] args) {
        long x = Lon();
        x--;
        long res = 0;
        long i;

        for (i = 0; ; i++) {
            long term = (i + 1) * (1L << i);
            if (x < term) break;
            x -= term;
            res += (1L << i);
        }

        res += x / (i + 1);
        long mod = x % (i + 1);
        long sumResult = getSum(res);
        long popResult = popCount(res + 1 >> (int) (Math.log(res + 1) / Math.log(2)) - (int) mod + 1);
       out.println(sumResult + popResult);
       out.flush();
       out.close();
    }

     //计算二进制中1的个数
    private static long popCount(long x) {
        long res = 0;
        while (x != 0) {
            res += x & 1;
            x >>>= 1;
        }
        return res;
    }

     // 计算所有自然数二进制中1的总个数
    private static long getSum(long x) {
        long res = 0;
        long cnt = 0;
        x++; // 转换为闭区间[1, x]

        while (x != 0) {
            if ((x & 1) != 0) {
                // 计算当前位为1时的贡献
                res += (cnt * (1L << (cnt - 1))) + ((1L << cnt) * popCount(x >> 1));
            }
            x >>>= 1;
            cnt++;
        }
        return res;
    }
}

7.甘蔗

【问题描述】
    小蓝种了一排甘蔗，甘蔗共 n 根，第 i 根甘蔗的高度为 ai 。小蓝想砍一些甘蔗下来品尝，但是他有强迫症，不希望甘蔗的高度显得乱糟糟的。具体来说，他给出了一个大小为 m 的整数集合 B = {b1,b2,…,bm} ，他希望在砍完甘蔗后，任意两根相邻的甘蔗之间的高度差 |ai - ai+1| 都要在这个集合 B 中。小蓝想知道他最少需要砍多少根甘蔗（对于高度为 h 的甘蔗，他可以将其砍成 x 高度的甘蔗，x ∈{0,1,2,…,h - 1}）。
【输入格式】
    输入的第一行包含两个正整数 n,m，用一个空格分隔。
    第二行包含 n 个正整数 a1,a2,…,an ，相邻整数之间使用一个空格分隔。
    第三行包含 m 个正整数 b1,b2,…,bm ，相邻整数之间使用一个空格分隔。
【输出格式】
    输出一行包含一个整数表示答案。如果不能满足条件，输出 -1 。
【样例输入】

6 3
6 7 3 4 9 12
2 3 5

【样例输出】

2

【样例说明】

其中一种方案：将 a2 砍为 3，再将 a3 砍为 1。

思路：动态规划，先确定dp表达式， dp[i][j]表示第i根甘蔗在高度为 j时，符合条件时最少需要砍多少根甘蔗，然后确定状态转移方程式，对于每根甘蔗的高度 j 是由前一根甘蔗的 j-b[k] 和 j+b[k] 转移过来，但需要注意这两个状态的高度必须在前一根甘蔗的高度范围内，然后进行初始化，当第一根甘蔗高度为a[1]时dp[1][a[1]] = 0，高度为i (i<a[1])时 dp[1][i] = 1，其余初始化为无穷大。

代码

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

public class Test2 {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }

    public static void main(String[] args) {

        int n =Int();
        int m =Int();
        int[] a = new int[n + 1];
        int[] b = new int[m + 1];
        for (int i = 1; i <= n; i++) {
            a[i] = Int();
        }
        for (int i = 1; i <= m; i++) {
            b[i] = Int();
        }
        int[][] dp = new int[n + 1][1001];
        for(int i = 0;i <= n; ++i){
            for(int j = 0; j <= 1000; ++j){
                dp[i][j] = Integer.MAX_VALUE/2;
            }
        }
        dp[1][a[1]] = 0;
        for (int i = 0; i < a[1]; ++i) {
            dp[1][i] = 1;
        }
        for (int i = 2; i <= n; ++i) {
            for (int j = 0; j <= a[i]; ++j) {
                for (int k = 1; k <= m; ++k) {
                    if (j == a[i]) {
                        if (j - b[k] >= 0) dp[i][j] = Math.min(dp[i - 1][j - b[k]], dp[i][j]);
                        if (j + b[k] <= a[i - 1]) dp[i][j] = Math.min(dp[i - 1][j + b[k]], dp[i][j]);
                    } else {
                        if (j - b[k] >= 0) dp[i][j] = Math.min(dp[i - 1][j - b[k]]+1, dp[i][j]);
                        if (j + b[k] <= a[i - 1]) dp[i][j] = Math.min(dp[i - 1][j + b[k]] + 1, dp[i][j]);
                    }
                }
            }
        }
        int res = dp[n][0];
        for (int i = 1; i <= a[n]; ++i) {
            res = Math.min(res, dp[n][i]);
        }
       out.println(res == Integer.MAX_VALUE/2 ? -1 : res);
        out.flush();
        out.close();

    }
}

8.原料采购

小蓝负责一家工厂的原料采购。

工厂有一辆运货卡车，其容量为 m。

工厂附近的采购点都在同一条路的同一方向上，一共有 n 个，每个采购点和工厂的距离各不相同。其中，第 i 个采购点的价格为 ai​, 库存为 bi​, 距离为 ci​。

卡车每行驶一单位长度的路径就需要额外花费 o。（返程没有花费，你也可以认为 o 实际是行驶两单位长度的花费）

请计算将卡车装满最少需要花费多少钱，如果没有任何方案可以装满请输出 −1。
输入格式

输入的第一行包含三个正整数 n,m,o，相邻整数之间使用一个空格分隔。

接下来 n 行，每行包含三个正整数 ai​,bi​,ci​ 表示一个采购点，相邻整数之间使用一个空格分隔。
输出格式

输出一行包含一个整数表示答案，即装满卡车所需的最小花费。
输入输出样例

输入

3 5 1
99 9 1
3 4 99
1 2 190

输出

201

思路:贪心+优先队列，使用最大堆将采购点的原料按价格从高到低排序，先从前到后遍历原料装入卡车，当卡车装满后，将遍历到原料的价格与最大堆中堆顶原料的最高价格进行比较，若当前价格低于堆顶原料，则替换堆顶原料，更新总费用，并记录以当前点为最远距离的总费用。

代码

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

public class Main {
    private static StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter out =
            new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    private static int Int() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (int) st.nval;
    }

    private static Long Lon() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return (long) st.nval;
    }

    private static Double Dou() {
        try {
            st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return st.nval;
    }

    private static String Line() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return s;
    }

    static final int MAXN = 1000005;
    static final long INF = (long) 3e18;
    static int n, m, o;
    static long[] a = new long[MAXN];
    static long[] b = new long[MAXN];
    static long[] c = new long[MAXN];
    static long cost, use, sum;
    static long ans = INF;

    static class Node implements Comparable<Node> {
        long price;
        long wei;

        public Node(long price, long wei) {
            this.price = price;
            this.wei = wei;
        }

        @Override
        public int compareTo(Node x) {
            return Long.compare(x.price, this.price); // 大顶堆
        }
    }

    public static void main(String[] args) {
        n = Int();
        m = Int();
        o = Int();
        for (int i = 1; i <= n; i++) {
            a[i] = Lon();
            b[i] = Lon();
            c[i] = Lon();
            use += b[i];
        }

        if (use < m) {
            out.println(-1);
            return;
        }

        PriorityQueue<Node> q = new PriorityQueue<>();

        for (int i = 1; i <= n; i++) {
            if (cost + b[i] <= m) {
                q.offer(new Node(a[i], b[i]));
                cost += b[i];
                sum += (a[i] * b[i]);
            } else {
                if (cost < m) {
                    long delta = m - cost;
                    q.offer(new Node(a[i], delta));
                    b[i] -= delta;
                    sum += a[i] * delta;
                    cost = m;
                }

                while (!q.isEmpty() && b[i] > 0) {
                    Node u = q.poll();
                    if (u.price <= a[i]) {
                        q.offer(u);
                        break;
                    }

                    if (b[i] >= u.wei) {
                        q.offer(new Node(a[i], u.wei));
                        b[i] -= u.wei;
                        sum -= (u.price - a[i]) * u.wei;
                    } else {
                        q.offer(new Node(a[i], b[i]));
                        q.offer(new Node(u.price, u.wei - b[i]));
                        sum -= (u.price - a[i]) * b[i];
                        b[i] = 0;
                    }
                }

                ans = Math.min(ans, sum + c[i] * o);
            }
        }

        out.println(ans);
        out.flush();
        out.close();
    }
}
vibag
关注
第十六届 -- 蓝桥杯Web开发大学组省赛复盘
一个前端人，游戏开发魂。
05-01 792
先说结论，web组难度分布一般为前6~7题为简单，基础扎实就没啥问题。最后三道题个人觉得也没啥难度，但是实现过程相对复杂（我还是太拉了，比赛的时候居然没来得及写完）。因为是所有本科大学一起比，作为双非文科院校的渣滓，出成绩前有点担心新疆其他两所211高校可能存在高手抢夺省一道名额。不过看来我的担心还是多余了，拿了省一（顺手摘了第一☝️），下面来复盘一下这次的省赛。试题序号、试题名称及基础源代码文件夹名称对应如下：从难题的分布可以看出，从第5~6道Node的题目开始，就进入了中等题的难度范围。比较麻烦的几道分
第十六届蓝桥杯JavaB组题目题解解析（一卷）
jnimiijabc的博客
04-27 1503
今年蓝桥杯省赛一卷考题考察的难度控制在中等题范围内，涉及到数论、图论、贪心等经典算法，对于选手的数学推导和贪心优化能力也有一定考量。
【蓝桥杯】第十六届蓝桥杯C/C++大学B组个人反思总结
2303_80737493的博客
04-30 5525
这是我第一次参加蓝桥杯大赛，我将通过一下 4 点来总结我的整个蓝桥杯经历。
2024第15届蓝桥杯javab组复盘
qq_66228897的博客
04-13 5850
这题是个dfs题，当时感觉条件太多了，一看就不会，采取了骗分的方法，因为t<=10,然后答案只会是Yes和No，所以我觉得可以骗，下面是骗分伪代码。​ 这题和去年的飞机降落有点像又不太像，总觉得太麻烦了我就没去多想，直接big胆骗分,下面是我的骗分伪代码(能过1个样例就满足了)​ 又是期望值，我的写法是floyd算法，一个传送门的距离算作1，算出每个点之间的最短传送门距离就好做了，这应该是正解？我直接不会，猜测答案区间范围直接输出打印。​ 纯暴力for循环，然后也知道给我4小时也跑不出来，所以不会做了。
第十四届蓝桥杯模拟赛第二期复盘
m0_61657604的博客
03-31 161
第十四届蓝桥杯模拟赛第二期
第十三届蓝桥杯省赛 python B组复盘
weixin_62650212的博客
03-21 4283
😎🥳😎备战蓝桥杯第一弹–复盘如果你对这篇文章感兴趣，欢迎在评论区留言，分享你的想法和建议。
第15届蓝桥杯C语言B组复盘。
2301_80480606的博客
04-16 759
第六题，没怎么看，直接printf("-1");，估计拿不到多少分。第四题高精度不会，直接double，估计只能拿一半分，5分。第七题暴力解的不知道对不对，算拿一半分吧，10分。第三题用暴力解的，估计只能拿一半分，5分。第五题暴力做的，就算得1/3分吧，5分。第一题排列组合，写出来了，5分。大概能得个30分左右，应该凉了。第二题看了一小时没看懂。
第十三届蓝桥杯省赛Python大学B组复盘
m0_52711790的博客
03-09 2421
本文主要复盘我在模拟第十三届蓝桥杯省赛Python大学B组的错题与值得追究的题。
【蓝桥杯嵌入式·真题解析】第十一届蓝桥杯嵌入式设计与开发项目省赛——程序设计试题
m0_70628523的博客
02-17 1672
​摘要：本文为作者对第十一届蓝桥杯嵌入式设计与开发项目省赛（第二场）——程序设计试题的解析。本文包括“题目要求”、“程序设计”、“效果展示”3个部分。供复盘使用。若发现错误之处，请不吝赐教。
2024年十五届蓝桥杯省赛大学B组真题（Java残缺版）
2302_76207485的博客
04-30 1万+
2024年十五届蓝桥杯省赛大学B组真题（Java完整版）题解
【蓝桥杯嵌入式·真题解析】第十三届蓝桥杯嵌入式设计与开发项目省赛（第二场）——程序设计试题
m0_70628523的博客
02-21 2780
摘要：本文为作者对第十三届蓝桥杯嵌入式设计与开发项目省赛（第二场）——程序设计试题的解析。本文包括“题目要求”、“程序设计”、“效果展示”3个部分。供复盘使用。若发现错误之处，请不吝赐教。
【蓝桥杯嵌入式·模拟解析】第十五届蓝桥杯嵌入式设计与开发项目模拟赛（第三期）——程序设计试题
m0_70628523的博客
04-04 1276
摘要：本文为作者对第十五届蓝桥杯嵌入式设计与开发项目模拟赛（第三期）——程序设计试题的解析。本文包括“题目要求”、“程序设计”、“效果展示”3个部分。供复盘使用。若发现错误之处，请不吝赐教。
第十四届蓝桥杯单片机组（赛题+程序）
热门推荐
qq_53520534的博客
04-30 2万+
第十四届蓝桥杯单片机组（赛题+程序） 考于2023.4.8 ，于2023.4.28 复盘。 今年的题目是比较难的了，模块多，而且逻辑也更加复杂，考了NE555、I2C、DS1302、DS18B20，同时客观题也不好做。笔者客观题只对3个，程序题大概完成80%，勉强进入省一。
【蓝桥杯省赛真题49】python偶数 第十五届蓝桥杯青少组Python编程省赛真题解析
青少年编程学习指导
05-15 614
本文详细解析了第十五届蓝桥杯青少组Python比赛省赛真题中的“偶数”题目。题目要求输入一个偶数n，计算n可以由多少个2相加得到。解题策略是将输入的n转换成整数，然后对2进行整除运算，最后输出结果。文章还提供了程序编写的具体代码和运行结果，并分析了考点，包括input函数、int函数、整除运算和print函数的使用。此外，文章推荐了Python比赛和考级的相关学习资料，适合准备参加Python编程比赛和考级的学生参考。
蓝桥杯2300 质数拆分
咚咚轩的博客
05-19 312
将 2022 拆分成不同的质数的和，请问最多拆分成几个？
蓝桥杯框架-LED蜂鸣器继电器
2402_89015641的博客
05-19 325
框架移植完毕，我们可以随意操作led了：在框架中，Led_Proc函数是空的，加入以下三句话就可以点亮第一，三，四个led。在.c文件中右键，导入头文件：keil自动帮我们加入了单片机的头文件，我们将他Ctrl X下来，粘贴到led.h中。左上角的Text1是我们Ctrl N是生成的文件，我们将他保存在User下面，并且命名为main.c，如下图操作。可以看到keil的文件管理：led.c已经添加进来了，那led.h怎么添加呢？在扳手中添加，如下图：将led.h文件的上一级文件Driver添加进来即可。
蓝桥杯19681 01背包
咚咚轩的博客
05-18 722
有 N 件物品和一个体积为 M 的背包。第 i 个物品的体积为 vi​，价值为 wi​。每件物品只能使用一次。请问可以通过什么样的方式选择物品，使得物品总体积不超过 M 的情况下总价值最大，输出这个最大价值即可。接下来 N 行，每行输入两个整数 vi,wi​。(0≤vi,wi≤1000)第一行输入两个正整数 N,M。(1≤N,M≤1000)输出一个整数，表示符合题目要求的最大价值。你可以选择第二个物品和第三个物品。分别考虑前1~4个物品时，
蓝桥杯 2024 C++国 B最小字符串
2301_80155689的博客
05-15 1095
题目要求将给定的小写字母插入到字符串中，使得最终字符串的字典序最小
蓝桥杯框架-按键数码管
最新发布
2402_89015641的博客
05-20 260
上一节已经一步步移植了led模板，本节移植按键和数码管的模板，但我不会再教移植，我直接给出main.c，key.c，key.h，seg.c，seg.h，init.c，init.h的代码，你们自己移植。Key_Down的值等于板子上按键的丝印号，如S7按下的一瞬间Key_Down等于7。Key_Old的值也等于板子上按键的丝印号，如S7一直按下，则Key_Old一直为7。所有的.h代码：引用单片机的头文件+.c中函数的声明。表示第一个数码管显示0。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值