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。

相关推荐
让我们一起加油好吗7 天前
【基础算法】01BFS
数据结构·c++·算法·bfs·01bfs
_OP_CHEN8 天前
C++基础:(十五)queue的深度解析和模拟实现
开发语言·c++·stl·bfs·queue·容器适配器·queue模拟实现
让我们一起加油好吗11 天前
【基础算法】多源 BFS
c++·算法·bfs·宽度优先·多源bfs
Espresso Macchiato13 天前
Leetcode 3710. Maximum Partition Factor
leetcode·职场和发展·广度优先遍历·二分法·leetcode hard·leetcode 3710·leetcode双周赛167
Espresso Macchiato20 天前
Leetcode 3702. Longest Subsequence With Non-Zero Bitwise XOR
leetcode medium·异或操作·leetcode 3702·leetcode周赛470
Espresso Macchiato21 天前
Leetcode 3694. Distinct Points Reachable After Substring Removal
滑动窗口·leetcode medium·leetcode双周赛166·leetcode 3694
Espresso Macchiato21 天前
Leetcode 3698. Split Array With Minimum Difference
leetcode medium·分类讨论·leetcode周赛469·leetcode 3698
Espresso Macchiato2 个月前
Leetcode 3665. Twisted Mirror Path Count
动态规划·leetcode medium·leetcode 3665·leetcode双周赛164
Espresso Macchiato2 个月前
Leetcode 3669. Balanced K-Factor Decomposition
动态规划·质因数分解·leetcode medium·leetcode 3669·leetcode周赛465
是阿建吖!2 个月前
【递归、搜索与回溯算法】穷举、暴搜、深搜、回溯、剪枝
算法·bfs·剪枝