【华为OD-E卷-预订酒店 100分（python、java、c++、js、c）】

题目

放暑假了，小明决定到某旅游景点游玩，他在网上搜索到了各种价位的酒店（长度为 n 的数组 A），他的心理价位是 x 元，
请帮他筛选出 k 个最接近 x 元的酒店（n ≥ k > 0），并由低到高打印酒店的价格

输入描述

第一行：n, k, x

第二行：A[0] A[1] A[2]...A[n-1]

输出描述

从低到高打印筛选出的酒店价格

备注

酒店价格数组 A 和小明的心理价位 x 均为整型数据（0 < n, k, x < 10000）优先选择价格最接近心理价位的酒店，若两家酒店距离心理价位差价相同，则选择价格较低的酒店。（比如 100 元和 300 元距离心理价位 200 元同样接近，此时选择 100 元）酒店价格可能相同重复

用例

用例一：

输入：

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

输出：

4 5 6 7 8

用例二：

输入：

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

输出：

4 5 6 7

用例三：

输入：

6 3 1000
30 30 200 500 70 300

输出：

200 300 500

python解法

解题思路：
解题思路：
输入有三个值：n 表示酒店数量，k 表示需要找出离目标价格最接近的 k 个酒店价格，x 表示目标价格。
将酒店价格数组 A 转换为元组 (差值, 酒店价格) 的形式，方便后续操作。
使用 Python 的 heapq.nsmallest 方法从生成的差值列表中获取差值最小的 k 个元素。
取出这些元素对应的酒店价格，并将它们排序后输出，确保结果按从小到大的顺序排列。

python 复制代码

import heapq

# 读取输入数据
n, k, x = map(int, input().split())  # n 为酒店数量，k 为需要找出的酒店数量，x 为目标价格
A = list(map(int, input().split()))  # A 为酒店价格列表

# 计算差值并存储元组 (差值, 酒店价格)，用于后续查找最近的酒店
arr = [(abs(a - x), a) for a in A]

# 从堆中获取 k 个最小差值的酒店价格
closest_hotels = heapq.nsmallest(k, arr)

# 提取酒店价格并按升序排序
result = sorted(h[1] for h in closest_hotels)

# 输出结果
print(" ".join(map(str, result)))

java解法

解题思路
输入解析：首先读取输入的三个值：n（酒店数量），k（需要找出的酒店数量），x（目标价格）。然后读取酒店价格列表。
优先队列排序：通过一个优先队列（PriorityQueue）来存储每个酒店的价格和与目标价格 x 的差值。优先队列会按照差值（绝对值）进行排序，如果差值相同，则根据价格进行排序。
找出前 k 个最接近的酒店价格：使用优先队列的 poll 方法从队列中取出前 k 个最接近的酒店价格。
排序输出：将结果按价格升序排序并输出，确保符合题目要求。

java 复制代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 创建Scanner对象用于读取输入
        Scanner sc = new Scanner(System.in);

        // 读取输入的n, k, x，分别表示酒店数量、需要找出的酒店数量和目标价格
        int n = sc.nextInt();
        int k = sc.nextInt();
        int x = sc.nextInt();

        // 创建一个优先队列，存储由两部分组成的数组：价格和与目标价格x的差值
        // 优先队列根据差值（绝对差）进行排序，如果差值相同，则根据价格进行排序
        PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> 
                a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]
        );

        // 读取每个酒店的价格，并将价格和其与目标价格的差值存入优先队列
        for (int i = 0; i < n; i++) {
            int price = sc.nextInt();
            queue.offer(new int[]{price, Math.abs(price - x)});  // 将价格和差值作为数组存入队列
        }

        // 创建一个List来存储前k个最接近目标价格的酒店价格
        List<Integer> result = new ArrayList<>();

        // 从优先队列中取出前k个最接近的酒店价格
        for (int i = 0; i < k; i++) {
            result.add(queue.poll()[0]);  // 取出酒店价格并加入到结果列表
        }

        // 对结果列表进行排序，确保输出的价格按升序排列
        Collections.sort(result);

        // 输出最终结果，以空格分隔酒店价格
        for (int price : result) {
            System.out.print(price + " ");
        }
    }
}

C++解法

解题思路

cpp 复制代码

更新中

C解法

解题思路

c 复制代码

更新中

JS解法

解题思路

输入解析：

首先读取第一行输入，包含三个整数：n（酒店数量）、k（需要找出的酒店数量）和 x（目标价格）。

然后读取第二行输入，包含 n 个整数，即所有酒店的价格列表。

差值计算：

将每个酒店价格和目标价格 x 的绝对差值与价格形成一个二元数组 [差值, 价格]，以便后续排序。

差值排序：

按照差值从小到大对数组排序，差值相同时按照价格从小到大排序。

提取结果：

截取排序后的前 k 个元素，提取其价格，并对价格进行升序排序。

输出结果：

将最终的结果按升序输出，每个价格之间用空格分隔。

javascript 复制代码

const readline = require('readline');

// 创建读取输入的接口
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 监听第一行输入
rl.on('line', (input) => {
    // 第一行包含 n, k, x，分别表示酒店数量、需要找出的酒店数量和目标价格
    const [n, k, x] = input.split(' ').map(Number);

    // 监听第二行输入
    rl.on('line', (input) => {
        // 第二行包含酒店价格数组
        const A = input.split(' ').map(Number);

        // 创建一个数组，将每个价格和其与目标价格的差值存储为二元数组 [差值, 价格]
        const heap = A.map(a => [Math.abs(a - x), a]);

        // 按照差值从小到大排序；差值相同时按价格从小到大排序
        heap.sort((a, b) => a[0] - b[0]);

        // 截取前 k 个元素，并提取价格，随后对价格进行升序排序
        const result = heap.slice(0, k).map(item => item[1]).sort((a, b) => a - b);

        // 输出最终结果，多个价格之间用空格分隔
        console.log(result.join(' '));

        // 关闭输入接口
        rl.close();
    });
});

注意：

如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏