Leetcode 3629. Minimum Jumps to Reach End via Prime Teleportation

  • [Leetcode 3629. Minimum Jumps to Reach End via Prime Teleportation](#Leetcode 3629. Minimum Jumps to Reach End via Prime Teleportation)
    • [1. 解题思路](#1. 解题思路)
    • [2. 代码实现](#2. 代码实现)

1. 解题思路

这一题思路上还是比较直接的,就是一个广度优先遍历,考察各条路径当中最先到达终点的走法。

但是,要进行路径的遍历,我们需要提前计算出jump点,也就意味着我们必须要提前找出所有的素数节点以及其对应的可以跳跃的位置,即对于那些非素数的节点,我们要找出他们各自都有哪些质因素才行。

而这个就是一个基础优化的问题了,这里就不过多展开了,大家对这代码理解一下就行,简单来说就是一个数要么自己是一个素数,要么他必然可以拆成两个数的乘积,那么至少其有一个质因子小于其平方根,因此,我们就可以优化我们的遍历过程了。

2. 代码实现

给出python代码实现如下:

python 复制代码
def get_primes(n):
    status = [0 for _ in range(n+1)]
    primes = set()
    for i in range(2, n+1):
        if status[i] != 0:
            continue
        primes.add(i)
        for j in range(i, n+1, i):
            status[j] = 1
    return primes

PRIMES = get_primes(10**6)
PRIME_LIST = list(sorted(PRIMES))

class Solution:
    def minJumps(self, nums: List[int]) -> int:
        n = len(nums)

        @lru_cache(None)
        def get_prime_factors(num):
            if num in PRIMES:
                return [num]
            idx = bisect.bisect_right(PRIME_LIST, sqrt(num)+1)-1
            for i in range(idx, -1, -1):
                if num % PRIME_LIST[i] == 0:
                    while num % PRIME_LIST[i] == 0:
                        num = num // PRIME_LIST[i]
                    return [PRIME_LIST[i]] + get_prime_factors(num)
            return []
        
        primes = {num for num in nums if num in PRIMES}
        jump = defaultdict(list)
        for i, num in enumerate(nums):
            for p in get_prime_factors(num):
                if p in primes:
                    jump[p].append(i)     
        
        seen = {0}
        q = [(0, 0)]
        while q:
            step, idx = heapq.heappop(q)
            idx = -idx
            if idx == n-1:
                return step
            if idx-1 >= 0 and idx-1 not in seen:
                heapq.heappush(q, (step+1, -idx+1))
                seen.add(idx-1)
            if idx+1 < n and idx+1 not in seen:
                if idx+1 == n-1:
                    return step+1
                heapq.heappush(q, (step+1, -idx-1))
                seen.add(idx+1)
            if nums[idx] in PRIMES:
                for nxt in jump[nums[idx]]:
                    if nxt == n-1:
                        return step+1
                    if nxt not in seen:
                        heapq.heappush(q, (step+1, -nxt))
                        seen.add(nxt)
        return -1

提交代码评测得到:耗时3037ms,占用内存64.27MB。

相关推荐
柏箱2 个月前
容器里有10升油,现在只有两个分别能装3升和7升油的瓶子,需要将10 升油等分成2 个5 升油。程序输出分油次数最少的详细操作过程。
算法·bfs
芜湖xin2 个月前
【题解-洛谷】B4292 [蓝桥杯青少年组省赛 2022] 路线
算法·图论·bfs·图的遍历
Espresso Macchiato2 个月前
Leetcode 3572. Maximize Y‑Sum by Picking a Triplet of Distinct X‑Values
leetcode medium·leetcode 3572
laufing2 个月前
OD 算法题 B卷【最大岛屿体积】
bfs
Espresso Macchiato2 个月前
Leetcode 3568. Minimum Moves to Clean the Classroom
剪枝·广度优先遍历·leetcode medium·堆排·leetcode周赛452·leetcode 3568
Espresso Macchiato2 个月前
Leetcode 3567. Minimum Absolute Difference in Sliding Submatrix
leetcode·leetcode medium·leetcode周赛452·leetcode 3567
Espresso Macchiato2 个月前
Leetcode 3566. Partition Array into Two Equal Product Subsets
动态规划·leetcode medium·leetcode 3566·leetcode周赛452
Espresso Macchiato2 个月前
Leetcode 3557. Find Maximum Number of Non Intersecting Substrings
动态规划·leetcode medium·leetcode 3557·leetcode双周赛157
无影无踪的青蛙2 个月前
[C++]洛谷B3626 跳跃机器人(题干 + 详细讲解, BFS练习题)
开发语言·c++·算法·bfs·广度优先