Acwing 周赛145 解题报告 | 珂学家 | 贪心构造

最新推荐文章于 2024-10-01 05:07:35 发布

珂朵莉酱

最新推荐文章于 2024-10-01 05:07:35 发布

阅读量288

点赞数 6

分类专栏： Acwing周赛解题报告文章标签： leetcode 职场和发展开发语言 java 算法

本文链接：https://blog.csdn.net/m0_66102593/article/details/136493451

版权

Acwing周赛解题报告专栏收录该内容

8 篇文章 1 订阅

订阅专栏

文章讲述了在一场IT竞赛中，涉及的三道题目：贪心构造题A通过模拟解决，避免浮点运算；套餐设计B采用枚举或二分法，数据范围小时直接枚举；分班C则需利用Java的排序漏洞修复，通过包装类保证稳定性。

摘要由CSDN通过智能技术生成

前言

在这里插入图片描述

整体评价

VP了这场比赛，偏简单吧。T3是道贪心构造题，卡语言，因为题和数都是从CF拿来的。

A. 平均成绩

思路: 模拟

这边有个小技巧，就是规避浮点运算。

可以左右侧都乘以3。

#include <bits/stdc++.h>

using namespace std;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    if (a + b + c > 180) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}

B. 套餐设计

思路: 枚举/二分

这题枚举就行，因为数据范围小

当然这题如果数据范围大，最好用二分，他有明显的二阶段性。

#include <bits/stdc++.h>

using namespace std;

int main() {
    
    int n, m;
    cin >> n >> m;
    map<int, int> mp;
    for (int i = 0; i < m; i++) {
        int v;
        cin >> v;
        mp[v]++;
    }
    
    int res = 0;
    for (int i = m / n; i >= 1; i--) {
        int tmp = 0;
        for (auto iter = mp.begin(); iter != mp.end(); iter++) {
            tmp += iter->second / i;
        }
        if (tmp >= n) {
            res = i;
            break;
        }
    }
    
    cout << res << endl;
    
    return 0;
}

C. 分班

思路: 贪心 + 构造

题外话:

因为Acwing周赛都是CF原题，CF喜欢攻击JDK8的sort漏洞，而Acwing平台用的是JDK8，所以这题很遗憾，卡java。

那如何破解呢？

使用包装类，而不是基本类型，进行排序(走的是稳定排序, 即归并排序)

Integer[] arr = new Integer[n * k];
for (int i = 0; i < n * k; i++) {
    arr[i] = sc.nextInt();
}
Arrays.sort(arr);

// 代替如下代码
int[] arr = new int[n * k];
for (int i = 0; i < n * k; i++) {
    arr[i] = sc.nextInt();
}
Arrays.sort(arr);

代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) {
        AReader sc = new AReader();
        int n = sc.nextInt(), k = sc.nextInt(), l = sc.nextInt();
        Integer[] arr = new Integer[n * k];
        for (int i = 0; i < n * k; i++) {
            arr[i] = sc.nextInt();
        }

        Arrays.sort(arr);
        int pos = 0, cnt = 0;
        while (pos < n * k && arr[pos] - arr[0] <= l) {
            cnt++;
            pos++;
        }

        if (cnt < n) {
            System.out.println(0);
            return;
        }

        long res = 0;
        int c = 0;
        for (int i = 0; i < n; i++) {
            int left = n - 1 - i;
            int f = Math.min(k, cnt - left);
            res += arr[c];
            cnt -= f;
            c += f;
        }
        System.out.println(res);
    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }

}