Leetcode 3629. Minimum Jumps to Reach End via Prime Teleportation

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

• 题目链接：3629. Minimum Jumps to Reach End via Prime Teleportation

1. 解题思路

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

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

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

2. 代码实现

给出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。