返回目录

题目描述

公司组织了一次考试,现在考试结果出来了，想看一下有没人存在作弊行为,但是员工太多了,需要先对员工进行一次过滤,再进一步确定是否存在作弊行为。

过滤的规则为:找到分差最小的员工ID对(p1,p2)列表,要求p1<p2

员工个数取值范国:O<n<100000

员工ID为整数,取值范围:0<=n<=100000

考试成绩为整数,取值范围:0<=score<=300

输入描述

员工的ID及考试分数

输出描述

分差最小的员工ID对(p1,p2)列表,要求p1<p2。每一行代表一个集合,每个集合内的员工ID按顺序排列,多行结果也以员工对中p1值大小升序排列(如果p1相同则p2升序)。

示例：

Python算法源码

# 读取员工数量
n = int(input())

# 创建一个列表来存储员工的ID和分数
score_list = []
for _ in range(n):
    id, score = map(int, input().split())
    score_list.append((id, score))

# 按分数升序对员工进行排序
score_list.sort(key=lambda x: x[1])

min_diff = float('inf')
pairs = []

# 比较每对员工的分数差
for i in range(n - 1):
    for j in range(i + 1, n):
        cur_diff = score_list[j][1] - score_list[i][1]
        if cur_diff < min_diff:
            pairs.clear()
            min_diff = cur_diff
            pairs.append((min(score_list[i][0], score_list[j][0]), max(score_list[i][0], score_list[j][0])))
        elif cur_diff == min_diff:
            pairs.append((min(score_list[i][0], score_list[j][0]), max(score_list[i][0], score_list[j][0])))
        else:
            break

# 对ID对进行排序
pairs.sort()

# 输出ID对
for pair in pairs:
    print(pair[0], pair[1])

C算法源码

#include <stdio.h>
#include <stdlib.h>

// 定义一个表示两个整数的结构体
struct Pair {
    int first;  // 第一个元素
    int second; // 第二个元素
};

// 比较函数，用于根据第二个元素对结构体数组进行排序
int compare(const void *a, const void *b) {
    struct Pair *p1 = (struct Pair *)a;
    struct Pair *p2 = (struct Pair *)b;
    return (p1->second - p2->second);
}

int main() {
    // 读取员工数量
    int n;
    scanf("%d", &n);

    // 分配内存来存储员工的ID和分数
    struct Pair *scoreList = (struct Pair *)malloc(n * sizeof(struct Pair));

    // 读取员工的ID和分数
    for (int i = 0; i < n; i++) {
        int id, score;
        scanf("%d %d", &id, &score);
        scoreList[i].first = id;
        scoreList[i].second = score;
    }

    // 按分数升序对员工进行排序
    qsort(scoreList, n, sizeof(struct Pair), compare);

    int minDiff = __INT_MAX__;  // 记录最小的分数差
    struct Pair *pairs = (struct Pair *)malloc(n * sizeof(struct Pair)); // 分配内存来存储符合条件的ID对
    int pairIndex = 0;  // 记录符合条件的ID对的数量

    // 比较每对员工的分数差
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int curDiff = scoreList[j].second - scoreList[i].second;
            if (curDiff < minDiff) {
                minDiff = curDiff;
                pairs[0].first = (scoreList[i].first < scoreList[j].first) ? scoreList[i].first : scoreList[j].first;
                pairs[0].second = (scoreList[i].first > scoreList[j].first) ? scoreList[i].first : scoreList[j].first;
                pairIndex = 1;
            } else if (curDiff == minDiff) {
                pairs[pairIndex].first = (scoreList[i].first < scoreList[j].first) ? scoreList[i].first : scoreList[j].first;
                pairs[pairIndex].second = (scoreList[i].first > scoreList[j].first) ? scoreList[i].first : scoreList[j].first;
                pairIndex++;
            } else {
                break;
            }
        }
    }

    // 对ID对进行排序
    qsort(pairs, pairIndex, sizeof(struct Pair), compare);

    // 输出ID对
    for (int i = 0; i < pairIndex; i++) {
        printf("%d %d\n", pairs[i].first, pairs[i].second);
    }

    // 释放内存
    free(scoreList);
    free(pairs);

    return 0;
}

Java算法源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取员工数量
        int n = scanner.nextInt();

        // 创建一个List来存储员工的ID和分数
        List<Pair> scoreList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int id = scanner.nextInt();
            int score = scanner.nextInt();
            scoreList.add(new Pair(id, score));
        }

        // 按分数升序对员工进行排序
        Collections.sort(scoreList);

        int minDiff = Integer.MAX_VALUE;
        List<Pair> pairs = new ArrayList<>();

        // 比较每对员工的分数差
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                int curDiff = scoreList.get(j).getSecond() - scoreList.get(i).getSecond();
                if (curDiff < minDiff) {
                    pairs.clear();
                    minDiff = curDiff;
                    pairs.add(new Pair(Math.min(scoreList.get(i).getFirst(), scoreList.get(j).getFirst()),
                            Math.max(scoreList.get(i).getFirst(), scoreList.get(j).getFirst())));
                } else if (curDiff == minDiff) {
                    pairs.add(new Pair(Math.min(scoreList.get(i).getFirst(), scoreList.get(j).getFirst()),
                            Math.max(scoreList.get(i).getFirst(), scoreList.get(j).getFirst())));
                } else {
                    break;
                }
            }
        }

        // 对ID对进行排序
        Collections.sort(pairs);

        // 输出ID对
        for (Pair pair : pairs) {
            System.out.println(pair.getFirst() + " " + pair.getSecond());
        }
    }
}

class Pair implements Comparable<Pair> {
    private int first;
    private int second;

    public Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }

    public int getFirst() {
        return first;
    }

    public int getSecond() {
        return second;
    }

    @Override
    public int compareTo(Pair other) {
        return Integer.compare(this.second, other.second);
    }
}