2748-美丽下标对的数目

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:23 2023-09-13 16:06:23 Updated    

给你一个下标从 0 开始的整数数组 nums 。如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果
nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和
nums[j] 是一组 美丽下标对 。

返回 nums 中 美丽下标对 的总数目。

对于两个整数 x 和 y ，如果不存在大于 1 的整数可以整除它们，则认为 x 和 y 互质 。换而言之，如果 gcd(x, y) == 1 ，则认为 x 和 y 互质，其中 gcd(x, y) 是 x 和 k 最大公因数 。

示例 1：

**输入：** nums = [2,5,1,4]
**输出：** 5
**解释：** nums 中共有 5 组美丽下标对：
i = 0 和 j = 1 ：nums[0] 的第一个数字是 2 ，nums[1] 的最后一个数字是 5 。2 和 5 互质，因此 gcd(2,5) == 1 。
i = 0 和 j = 2 ：nums[0] 的第一个数字是 2 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(2,1) == 1 。
i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(5,1) == 1 。
i = 1 和 j = 3 ：nums[1] 的第一个数字是 5 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(5,4) == 1 。
i = 2 和 j = 3 ：nums[2] 的第一个数字是 1 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(1,4) == 1 。
因此，返回 5 。

示例 2：

**输入：** nums = [11,21,12]
**输出：** 2
**解释：** 共有 2 组美丽下标对：
i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1 。gcd(1,1) == 1 。
i = 0 和 j = 2 ：nums[0] 的第一个数字是 1 ，nums[2] 的最后一个数字是 2 。gcd(1,2) == 1 。
因此，返回 2 。

提示：

  • 2 <= nums.length <= 100
  • 1 <= nums[i] <= 9999
  • nums[i] % 10 != 0

设 x=\textit{nums}[i]。

遍历 nums，同时维护 x 的最高位的出现次数 cnt。枚举 [1,9] 内的数字 y，如果与 x\bmod 10 互质则答案加上 cnt}[y]。

具体请看【周赛 351 视频讲解】 的第一题，欢迎点赞！

[sol-Python3]
1
2
3
4
5
6
7
8
9
10
class Solution:
    def countBeautifulPairs(self, nums: List[int]) -> int:
        ans, cnt = 0, [0] * 10
        for x in nums:
            for y in range(1, 10):
                if cnt[y] and gcd(x % 10, y) == 1:
                    ans += cnt[y]
            while x >= 10: x //= 10  # 这里需要 O(log x) 的时间
            cnt[x] += 1  # 统计最高位的出现次数
        return ans
[sol-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public int countBeautifulPairs(int[] nums) {
        int ans = 0;
        var cnt = new int[10];
        for (int x : nums) {
            for (int y = 1; y < 10; y++)
                if (cnt[y] > 0 && gcd(x % 10, y) == 1)
                    ans += cnt[y];
            while (x >= 10) x /= 10; // 这里需要 O(log x) 的时间
            cnt[x]++; // 统计最高位的出现次数
        }
        return ans;
    }

    private int gcd(int a, int b) {
        while (a != 0) {
            int tmp = a;
            a = b % a;
            b = tmp;
        }
        return b;
    }
}
[sol-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    int countBeautifulPairs(vector<int> &nums) {
        int ans = 0, cnt[10]{};
        for (int x: nums) {
            for (int y = 1; y < 10; y++)
                if (cnt[y] && gcd(x % 10, y) == 1)
                    ans += cnt[y];
            while (x >= 10) x /= 10; // 这里需要 O(log x) 的时间
            cnt[x]++; // 统计最高位的出现次数
        }
        return ans;
    }
};
[sol-Go]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func countBeautifulPairs(nums []int) (ans int) {
	cnt := [10]int{}
	for _, x := range nums {
		for y := 1; y < 10; y++ {
			if cnt[y] > 0 && gcd(x%10, y) == 1 {
				ans += cnt[y]
			}
		}
		for x >= 10 { // 这里需要 O(log x) 的时间
			x /= 10
		}
		cnt[x]++ // 统计最高位的出现次数
	}
	return
}

func gcd(a, b int) int {
	for a != 0 {
		a, b = b%a, a
	}
	return b
}

复杂度分析

  • 时间复杂度：\mathcal{O}(n(k+\log U))，其中 n 为 nums 的长度，k=10，U=\max(\textit{nums})。GCD 的时间视作 \mathcal{O}(1)。
  • 空间复杂度：\mathcal{O}(k)。
 Comments
On this page
2748-美丽下标对的数目