10 5 6
1 2 3 4 5 6 7 8 9 10
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

4 5 6 7 8
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

10 4 6
10 9 8 7 6 5 4 3 2 1
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

4 5 6 7
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

6 3 1000
30 30 200 500 70 300
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

200 300 500
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

• 1

python解法

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

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)))

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

java解法

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

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 + " ");
        }
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

C++解法

• 解题思路

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1

C解法

• 解题思路

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1

JS解法

• 解题思路

• 输入解析：
  首先读取第一行输入，包含三个整数：n（酒店数量）、k（需要找出的酒店数量）和 x（目标价格）。
  然后读取第二行输入，包含 n 个整数，即所有酒店的价格列表。
  差值计算：
  将每个酒店价格和目标价格 x 的绝对差值与价格形成一个二元数组 [差值, 价格]，以便后续排序。
  差值排序：
  按照差值从小到大对数组排序，差值相同时按照价格从小到大排序。
  提取结果：
  截取排序后的前 k 个元素，提取其价格，并对价格进行升序排序。
  输出结果：
  将最终的结果按升序输出，每个价格之间用空格分隔。

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();
    });
});

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

注意：

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

发表评论

登录后才能发表评论和回复 注册

/ 登录

提交评论

评论记录：

未查询到任何数据！

回复评论：

×

关闭 提交评论