给定单位数字的整数之和，最多N

问题描述

给定一个有 $n$ 个正整数的数组 $A$，求其中所有单位数字（指数字的个位数字）相同的两两配对数字的和，最多输出 $N$ 个配对数。

示例

输入:

A = [12, 23, 34, 45, 56, 67, 78, 89, 90]
N = 3

输出:

[(23, 90), (34, 67), (45, 56)]

解题思路

方法一

首先，我们可以遍历整个数组，将每个数字按照单位数字的值分类。具体来说，可以使用字典来记录每个单位数字对应的数字集合。然后，我们再遍历字典中每个单位数字的数字集合，两两配对数字，记录其和并保留前 $N$ 个和值最大的配对。

方法二

另一种思路是通过数学方法，直接计算每个单位数字的数字和（即各位数字之和），并记录相同数字和的数字集合。然后，遍历字典，计算每个数字集合中两两配对数字的和，并保留前 $N$ 个和值最大的配对。

代码实现

Python 代码

def find_unit_digit_pairs(A, N):
    d = {}
    for num in A:
        unit_digit = num % 10
        if unit_digit not in d:
            d[unit_digit] = [num]
        else:
            d[unit_digit].append(num)

    pairs = []
    for nums in d.values():
        nums_len = len(nums)
        if nums_len < 2:
            continue

        for i in range(nums_len - 1):
            for j in range(i + 1, nums_len):
                pairs.append((nums[i], nums[j]))
                if len(pairs) == N:
                    return pairs

    pairs.sort(reverse=True, key=lambda x: x[0] + x[1])
    return pairs[:N]

Java 代码

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;

public class UnitDigitPairs {

    public static List<Pair> findUnitDigitPairs(int[] A, int N) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int num : A) {
            int unitDigit = num % 10;
            map.putIfAbsent(unitDigit, new ArrayList<>());
            map.get(unitDigit).add(num);
        }

        PriorityQueue<Pair> pq = new PriorityQueue<>(N);
        for (List<Integer> nums : map.values()) {
            int numsLen = nums.size();
            if (numsLen < 2) {
                continue;
            }

            for (int i = 0; i < numsLen - 1; i++) {
                for (int j = i + 1; j < numsLen; j++) {
                    Pair pair = new Pair(nums.get(i), nums.get(j));
                    if (pq.size() < N) {
                        pq.offer(pair);
                    } else if (pq.peek().compareTo(pair) < 0) {
                        pq.poll();
                        pq.offer(pair);
                    }
                }
            }
        }

        List<Pair> pairs = new ArrayList<>();
        while (!pq.isEmpty()) {
            pairs.add(pq.poll());
        }
        pairs.sort((a, b) -> b.sum() - a.sum());
        return pairs.subList(0, Math.min(N, pairs.size()));
    }

    private static class Pair implements Comparable<Pair> {
        int x;
        int y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        int sum() {
            return x + y;
        }

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

总结

本题可以通过两种不同的思路解决，一种是使用字典分类后遍历，另一种是直接计算数字和并统计。两种方法的时间复杂度均为 $O(n^2)$，其中 $n$ 为数组 $A$ 的长度。虽然这种时间复杂度并不理想，但是当 $N$ 值较小，或者数组 $A$ 的可能取值数量较少时，它们的性能仍可接受。