LintCode : Jump Game II

Problem Description:

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

Examples:

Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump1 step from index 0 to 1, then 3 steps to the last index.)

Solution 1:

public class Solution {
    /**
     * @param A: A list of lists of integers
     * @return: An integer
     */
    private int[] steps;
    public int jump(int[] A) {
        // write your code here
        if (A == null || A.length == 0) {
            return -1;
        }
        steps = new int[A.length];
        steps[0] = 0;
        for (int i = 1; i < A.length; i++) {
            steps[i] = Integer.MAX_VALUE;
            for (int j = 0; j < i; j++) {
                if (steps[j] != Integer.MAX_VALUE && (j + A[j]) >= i) {
                    steps[i] = steps[j] + 1;
                    break;
                }
            }
        }
        return steps[A.length - 1];
    }
}

This version is easy to understand.The time complexity of this algorithm is O(n*n).

Solution 2:

public class Solution {
    /**
     * @param A: A list of lists of integers
     * @return: An integer
     */
    public int jump(int[] A) {
        // write your code here
        if (A == null || A.length == 0) {
            return -1;
        }
        int start = 0;
        int end = 0;
        int jumps = 0;
        while (end < A.length - 1) {
            jumps++;
            int farthest = end;
            for (int i = start; i <= end; i++) {
                if ((i + A[i]) > farthest) {
                    farthest = i + A[i];
                }
            }
            start =  end + 1;
            end = farthest;
        }
        return jumps;
    }
}

This is the greedy version solution, we maintain two pointers start and end, first initialize start and end to 0, which means we are at the index 0, then when end < A.length - 1, every time we jump, jumps++, we will choose to jump to the farthest we can jump from whatever index between start and end to make sure we will get the minimum jumps, so this is a greedy algorithm.