原文：https://yq.aliyun.com/articles/547799

描述：

題目：給定一個數組，裡面全是正整數。數字大小表示這一步最多可以向後移動幾個節點。總是從陣列第一個元素開始移動。問如何移動，可以以最少步數移動到最後一個節點。
例如：[3,4,2,1,3,1]初始狀態指向3表示下一步可以移動1格，或者2格，或者3格。
最優的方式是指向3的時候移動一步，第二次選擇移動4步，一共只需要兩步即可移動到陣列尾。

輸入：3,4,2,1,3,1

輸出：步經的點3,4,1

我的程式碼：

import java.util.ArrayList;
import java.util.Collections;
import 
 
java.util.List;

/**
 * Created by Administrator on 2018/4/15.
 */
public class MyLeastSteps {

    /*
    output 裡存放input中選中的index
     */
public static void leastSteps(int[] input,int[] output,int currstep){
        if(currstep == 0){
            //output = new int[input.length];
output[0] = 0;
        }

        int 
 
currindex = output[currstep];
        int canstep = input[currindex];
        if(currindex + canstep >= input.length-1){
            return;
        }
        List canget = new ArrayList();
        int level = 1;
        for(int i = currindex+1;i<=currindex + canstep;i++ ){
            int nextcanstep = input[i] +level;
            canget.add(nextcanstep);
            level++;
        }
        Collections.sort
 
(canget);
        int choose = (Integer) canget.get(canget.size() - 1);
        int livel2 = 1;
        for(int i = currindex+1;i<=currindex + canstep;i++ ){
            int nextcanstep = input[i] +livel2;
            if(nextcanstep == choose){
                currstep++;
                output[currstep] = i;
                leastSteps(input,output,currstep);
                break;
            }
            livel2++;
        }




    }



    public static void main(String[] args)
    {
        int[] case1 = new int[]{3,4,2,1,3,1,3,2,4,5,2,3,4,2,6,3};
        //01469,14
int[] case2 = new int[]{3};
        int[] case3 = new int[]{2,2,1};
        int[] case4 = new int[]{2,2,3,1};
        int[] output = new int[6];
        leastSteps(case1,output,0);
        for(int i : output){
            System.out.println(i);
        }
    }
}

=============原文如下=========

package com.hp.algorithm.leaststep;

import java.util.HashMap;
import java.util.Map;

public class LeastSteps2Last
{

public static int[] leastSteps2Last(int[] input){
    if(input.length == 1){
        return input;
    }
    
    //對於1~input[0]的每種步數i，如果走i步後①超過終點則break；②剛到終點則記錄路徑並return；③沒到終點，則基於走i補後的字陣列繼續呼叫本方法遞迴尋找路徑
    //每次迴圈可以返回一個路徑及其長度（超出長度的那次迴圈可能不會返回）再在返回的這些路徑中取最小長度的路徑,貌似用list就行哦，傻了
    Map<Integer, int[]> subSteps = new HashMap<Integer, int[]>();
    for(int i = 1; i <= input[0]; i++){
        //如果走i步還沒到列表結尾，則再次呼叫走i步後的子列表繼續走
        if(1 + i < input.length){
            int[] nextSubList = new int[input.length - i];
            //src:源陣列  srcPos:源陣列要複製的起始位置  dest:目的陣列  destPos:目的陣列放置的起始位置  length:要複製的長度
            System.arraycopy(input, i, nextSubList, 0, nextSubList.length);
            //基於走i步後的子陣列再次呼叫本方法計算步數並返回
            int[] nextSteps = leastSteps2Last(nextSubList);
            
            //當前走i步的路徑currSteps=input[0] + nextSteps
            int[] currSteps = new int[nextSteps.length + 1];
            currSteps[0] = input[0];
            System.arraycopy(nextSteps, 0, currSteps, 1, nextSteps.length);
            subSteps.put(i, currSteps);
        //如果走i步剛好到結尾，則直接將這個路徑加入到map裡以作最短路徑對比
        }else if(1 + i == input.length){
            return new int[]{input[0],input[input.length-1]};
        }
        //如果走i步超出長度了，則不再嘗試更大的步數跨度
        else if(1 + i > input.length){
            break;
        }
    }
    
    int[] leastSteps = null;
    int stepNum = Integer.MAX_VALUE;
    for(Map.Entry<Integer, int[]> entry : subSteps.entrySet()){
        if(entry.getValue().length < stepNum){
            leastSteps = entry.getValue(); 
            stepNum = entry.getValue().length;
        };
    }
    return leastSteps;
}

/**
 * @param args
 */
public static void main(String[] args)
{
    int[] case1 = new int[]{3,4,2,1,3,1};
    int[] case2 = new int[]{3};
    int[] case3 = new int[]{2,2,1};
    int[] case4 = new int[]{2,2,3,1};
    int[] steps = leastSteps2Last(case4);
    for(int i : steps){
        System.out.println(i);
    }
}

}