题目如下:
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.
For example:
Given array A = [2,3,1,1,4]
The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)
分析如下:
看下面的图来理解index的跳动情况
我的代码:
学习左耳朵耗子的代码。
// 10ms
class Solution {
public:
    int jump(int A[], int n) {
        if (n <= 1) return 0;
        int coverPro = 0;
        int steps = 0;
        for (int i = 0; i <= coverPro && coverPro < n;) {
            if (coverPro >= n-1) return steps;
            if (A[i] == 0) return -1;
            if (A[i] + i >= coverPro) {
                coverPro = A[i] + i;
                ++steps;
            }
            int maxDistance = 0;
            int nextStart = i + 1;
            for (int j = i + 1; j <= coverPro; ++j) {
                if(A[j] + j > maxDistance) {
                    maxDistance = A[j] + j;
                    nextStart = j;
                }
            }
            i = nextStart;
        }
        return steps;
    }
};
一个更加简洁的答案,来自Kyle。
//10ms
class Solution {
public:
    int jump(int A[], int n) {
        if (n == 1) return 0;
        int step = 0;
        int index = 0;
        int distance = A[0];
        while (distance < n - 1) {
            ++step;
            int next_distance = distance;
            while (index < n && index <= distance) {
                next_distance = max(next_distance, index + A[index]);
                ++index;
            }
            if (next_distance <= distance) 
                return -1;
            distance = next_distance;
        }
        return step + 1;
    }
};
 
                   
                   
                   
                   
                            
 
                             
                             本文介绍了一个算法问题,即如何在给定的非负整数数组中找到从第一个元素到最后一个元素所需的最小跳跃次数。通过详细解析及两种实现方案,帮助读者理解如何高效地解决这一问题。
本文介绍了一个算法问题,即如何在给定的非负整数数组中找到从第一个元素到最后一个元素所需的最小跳跃次数。通过详细解析及两种实现方案,帮助读者理解如何高效地解决这一问题。
           
       
           
                 
                 
                 
                 
                 
                
               
                 
                 
                 
                 
                
               
                 
                 扫一扫
扫一扫
                     
              
             
                   1690
					1690
					
 被折叠的  条评论
		 为什么被折叠?
被折叠的  条评论
		 为什么被折叠?
		 
		  到【灌水乐园】发言
到【灌水乐园】发言                                
		 
		 
    
   
    
   
             
            


 
            