第一種比較容易的想法，可以建立一個標誌陣列，每一位的1或者0代表是否能到達這一位，在遍歷該陣列的同時根據陣列值更新標誌陣列的值。本來是沒通過的，有一個改進處在於遍歷到一個能夠到達的節點後，首先判斷從該節點出發是否能到達最後一位，如果可以就直接返回，不行的話，就老實更新陣列。貼程式碼

 1 class Solution {
 2 public:
 3     bool canJump(vector<int>& nums) 
 4     {
 5         vector<int> flag(nums.size(),0);
 6         flag[0] = 1
 
;
 7         for(int i = 0 ; i < nums.size() ; i++)
 8         {
 9             if(flag[i])
10             {
11                 if(nums[i]+i>=nums.size()-1)
12                 return true;
13                 for(int j = 1 ; j <= nums[i] && i+j<nums.size() ; j++)
14                 {
 
15                     flag[i+j] = 1;
16                 }
17             }
18         }
19         return flag[nums.size()-1];
20     }
21 };

所謂的貪心演算法，維護一個表示當前能夠到達的最遠位置的變數，為max_pos，所有小於等於該變數的位置都能夠達到。在遍歷陣列的過程中，如果當前位置的索引小於等於max_pos，代表該位置可以達到，並且計算從該位置出發能夠到達的最遠位置，與max_pos比較，若更大，則將該值賦給max_pos。在遍歷過程中，若max_size大於最遠索引，則直接返回。仔細想了下和自己方法的區別，就一個不同，用一個變數代替了我整個陣列，所以記憶體的消耗和賦值的開銷都小很多。貼程式碼

 1 class Solution {
 2 public:
 3     bool canJump(vector<int>& nums) 
 4     {
 5         int max_pos = 0;
 6         int n = nums.size();
 7         for(int i = 0 ; i < nums.size() ; i++)
 8         {
 9             if(i<=max_pos)
10             {
11                 max_pos = max(max_pos,i+nums[i]);
12             }  
13             if(max_pos>=n-1)
14             return true;          
15         }
16         return false;
17     }
18 };