跳转至

2310. 个位数字为 K 的整数之和

来源第 298 场周赛 Q2难度中等分数1558

题目描述

给你两个整数 num 和 k ，考虑具有以下属性的正整数多重集：

  • 每个整数个位数字都是 k 。
  • 所有整数之和是 num 。

返回该多重集的最小大小，如果不存在这样的多重集，返回 -1 。

注意：

  • 多重集与集合类似，但多重集可以包含多个同一整数，空多重集的和为 0 。
  • 个位数字 是数字最右边的数位。

 

示例 1：

输入：num = 58, k = 9
输出：2
解释：
多重集 [9,49] 满足题目条件，和为 58 且每个整数的个位数字是 9 。
另一个满足条件的多重集是 [19,39] 。
可以证明 2 是满足题目条件的多重集的最小长度。

示例 2：

输入：num = 37, k = 2
输出：-1
解释：个位数字为 2 的整数无法相加得到 37 。

示例 3：

输入：num = 0, k = 7
输出：0
解释：空多重集的和为 0 。

 

提示：

  • 0 <= num <= 3000
  • 0 <= k <= 9

解法

方法一：数学 + 枚举

思考

每个加数形如 \(10x+k\)，故 \(n\) 个数之和的个位由 \(n\times k\) 决定。\(num \le 3000\)，枚举个数 \(n\) 并检验 \(num-n\times k\) 是否为 \(10\) 的非负倍数即可。

从小到大尝试 \(n\)，第一个满足条件者即为最少个数；若直至 \(num\) 仍不成立则无解。

符合拆分条件的每个数都可以表示成 \(10x_i+k\)，若总共有 \(n\) 个数，那么 \(\textit{num}-n \times k\) 必然是 \(10\) 的倍数。

我们从小到达枚举 \(n\)，找到第一个满足 \(\textit{num}-n \times k\) 是 \(10\) 的倍数的 \(n\)。由于 \(n\) 不会超过 \(\textit{num}\)，因此 \(n\) 最大枚举至 \(\textit{num}\)。

也可以只考虑个位，个位满足，高位随意。

时间复杂度 \(O(n)\)，其中 \(n\) 为 \(\textit{num}\) 的大小。空间复杂度 \(O(1)\)。

1
2
3
4
5
6
7
8
class Solution:
    def minimumNumbers(self, num: int, k: int) -> int:
        if num == 0:
            return 0
        for i in range(1, num + 1):
            if (t := num - k * i) >= 0 and t % 10 == 0:
                return i
        return -1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
    public int minimumNumbers(int num, int k) {
        if (num == 0) {
            return 0;
        }
        for (int i = 1; i <= num; ++i) {
            int t = num - k * i;
            if (t >= 0 && t % 10 == 0) {
                return i;
            }
        }
        return -1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
public:
    int minimumNumbers(int num, int k) {
        if (num == 0) return 0;
        for (int i = 1; i <= num; ++i) {
            int t = num - k * i;
            if (t >= 0 && t % 10 == 0) return i;
        }
        return -1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
func minimumNumbers(num int, k int) int {
    if num == 0 {
        return 0
    }
    for i := 1; i <= num; i++ {
        t := num - k*i
        if t >= 0 && t%10 == 0 {
            return i
        }
    }
    return -1
}

1
2
3
4
5
6
7
8
9
function minimumNumbers(num: number, k: number): number {
    if (!num) return 0;
    let digit = num % 10;
    for (let i = 1; i < 11; i++) {
        let target = i * k;
        if (target <= num && target % 10 == digit) return i;
    }
    return -1;
}

方法二：数学 + 枚举（个位）

思考

方法一最多枚举 \(num\) 次。个位以 \(10\) 为周期，因此只需检查 \(n \le 10\) 是否使 \(n\times k\) 与 \(num\) 同余且不超过 \(num\)，常数更小。

只需枚举个数 \(n \le 10\)，使 \(n \times k\) 与 \(\textit{num}\) 个位相同且不超过 \(\textit{num}\)。

1
2
3
4
5
6
7
8
class Solution:
    def minimumNumbers(self, num: int, k: int) -> int:
        if num == 0:
            return 0
        for i in range(1, 11):
            if (k * i) % 10 == num % 10 and k * i <= num:
                return i
        return -1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Solution {
    public int minimumNumbers(int num, int k) {
        if (num == 0) {
            return 0;
        }
        for (int i = 1; i <= 10; ++i) {
            if ((k * i) % 10 == num % 10 && k * i <= num) {
                return i;
            }
        }
        return -1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
public:
    int minimumNumbers(int num, int k) {
        if (!num) return 0;
        for (int i = 1; i <= 10; ++i)
            if ((k * i) % 10 == num % 10 && k * i <= num)
                return i;
        return -1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func minimumNumbers(num int, k int) int {
    if num == 0 {
        return 0
    }
    for i := 1; i <= 10; i++ {
        if (k*i)%10 == num%10 && k*i <= num {
            return i
        }
    }
    return -1
}

方法三：记忆化搜索

思考

前两法依赖整除关系，实现紧凑但不易改成带额外约束的拆分。记忆化搜索按个位为 \(k\) 的数递减，子问题只与剩余值有关，可复用中间结果；在本题数据下正确，却比直接枚举更重。

枚举下一个个位为 \(k\) 的数，记忆化搜索凑出 \(\textit{num}\) 的最少个数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution:
    def minimumNumbers(self, num: int, k: int) -> int:
        @cache
        def dfs(v):
            if v == 0:
                return 0
            if v < 10 and v % k:
                return inf
            i = 0
            t = inf
            while (x := i * 10 + k) <= v:
                t = min(t, dfs(v - x))
                i += 1
            return t + 1

        if num == 0:
            return 0
        if k == 0:
            return -1 if num % 10 else 1
        ans = dfs(num)
        return -1 if ans >= inf else ans

评论