Frog Jump
This problem can be solved using dynamic programming (DP). We will keep track of the possible jump sizes at each stone and use them to determine whether the next stone can be reached. If we can reach the last stone, we return True
; otherwise, False
.
Here’s the Python code:


Explanation:
 We initialize a dictionary to keep track of possible jump sizes at each stone.
 We check the second stone to make sure it is reachable with a jump of size 1, as the problem statement specifies that the first jump must be 1 unit.
 For each stone, we calculate the next possible jump sizes (k1, k, k+1) and check if the next stone can be reached with these jump sizes.
 Finally, we check if there are any possible jump sizes for the last stone, and if so, return
True
; otherwise,False
.
10 Prerequisite LeetCode Problems
“Frog Jump” involves dynamic programming and recursion. Here are some simpler problems to build up the necessary skills:
70. Climbing Stairs: This problem is a simple case of dynamic programming and will introduce the basic concept.
198. House Robber: Another simple problem involving dynamic programming.
139. Word Break: This problem is more complex and introduces the idea of breaking a problem down into subproblems.
300. Longest Increasing Subsequence: This problem involves creating a dynamic programming solution for a nontrivial problem.
121. Best Time to Buy and Sell Stock: This problem can be solved with dynamic programming and introduces the concept of keeping track of previous results for future calculations.
322. Coin Change: This problem involves finding the optimal solution with the use of dynamic programming.
62. Unique Paths: This problem also uses dynamic programming to find the number of unique paths in a grid.
494. Target Sum: This problem involves a more complex dynamic programming solution.
646. Maximum Length of Pair Chain: This problem will involve coming up with a dynamic programming solution based on the ordering of pairs.
376. Wiggle Subsequence: This problem involves dynamic programming and requires careful thought about the state to store in the dynamic programming table.


Problem Classification
The task is to determine if a frog can cross a river by jumping on stones at various distances. This is a Crossing Feasibility Problem.
Language Agnostic Coding Drills
Understanding the Problem: We have a list of stones and each stone has a unit position in the array. The frog starts at stone 0 with a jump of size 0, and in each subsequent move, the frog can jump to the next stone using a size that is the same, less by one, or more by one than the previous jump size.
Working with Lists and Sets: The positions of stones are given in the form of a list. We convert this list into a set for faster access (O(1) time complexity). Understanding and practicing how to create and manipulate lists and sets would be beneficial.
Recursion: The problem uses a depthfirst search approach. The function
goFurther
is recursively called to try all possible jumps the frog can make. Understanding recursion and how to write recursive functions is vital here.Caching or Memorization: We see that there is a set
visited
used to remember the stones that we have visited with a particular jump size. This prevents unnecessary recomputations, thereby improving the efficiency of our code. Understanding how caching works is an important concept here.Conditional Statements: Conditional checks are a significant part of the code to decide when the recursion should end and whether the frog can jump to a certain stone. Understanding and practicing writing conditional statements would be crucial.
Returning from Functions: The functions are designed to return a Boolean value indicating whether a stone can be reached. The recursive function returns the result of other function calls. Understanding how return statements work in normal and recursive functions would be beneficial.
To solve this problem, start with the first stone and try to reach the end of the stone array with varying jump sizes. If we reach the end, return True; otherwise, keep trying with different stones and jump sizes. The stones visited with a particular jump size are remembered to prevent recomputation. If all possibilities are exhausted and the end is not reached, return False.
Targeted Drills in Python
Let’s write some Python code drills that incorporate the key concepts used in the given problem solution.
 Working with Lists and Sets


 Recursion


 Caching or Memorization


 Conditional Statements


 Returning from Functions


After understanding these smaller drills, you can understand the main problem better and see how these smaller components contribute to the overall solution. Each of the drills directly relates to a concept used in the main solution.