有自己的代码--题目:给定一个数组,里面全是正整数。数字大小表示这一步最多可以向后移动几个节点。总是从数组第一个元素开始移动。问如何移动,可以以最少步数移动到最后一个节点。

转载 2018年04月15日 19:20:26


原文: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);
    }
}

}




算法之最快到达终点问题。

算法之最快到达终点问题 题目:     给定一个正整数数组,每个元素大小表示从该元素出发最多可移动几个节点。假设总是从第一个元素开始移动。问如何移动可以以最少的步数移动到最后。...
  • yy1098029419
  • yy1098029419
  • 2017-08-23 17:05:04
  • 154

动归题目

题目:给定一个数组,里面全是正整数。数字大小表示这一步最多可以向后移动几个节点。总是从数组第一个元素开始移动。问如何移动,可以以最少步数移动到最后一个节点。 例如:[3,4,2,1,3,1]初始...
  • Likeaboy_fire
  • Likeaboy_fire
  • 2018-01-20 20:51:26
  • 295

路径搜索问题

之前碰到的很多问题都可以归结为路径搜索问题,就是求两点之间的路经 1)是否存在路径 2)求任意一条路径 3)求所有路径 求是否有路径和任意一条路径的时候,和正常遍历一样,一个点被mark之后不再访...
  • binling
  • binling
  • 2015-06-02 10:29:37
  • 672

搜索可以做到这一步吗?

  • kingundertree
  • kingundertree
  • 2009-05-21 21:22:00
  • 361

给定一个数字表示为数字数组,加上一个数字。

本题源自LeetCode --------------------------------------------------------- 思路:  数组的最后存放的是数的最低位,加上一个1 ...
  • i_am_bird
  • i_am_bird
  • 2017-10-26 09:29:15
  • 96

请问如何在一个List最开始插入一个元素,其他元素一次向后移动一位?

请问如何在一个List最开始插入一个元素,其他元素一次向后移动一位? [问题点数:20分]             不显示删除回复           显示所有回复            显...
  • evilcry2012
  • evilcry2012
  • 2017-12-21 08:38:35
  • 72

广度优先搜索求最短路径问题

//广度优先搜索求最短路径问题,处理以下问题: //题目:给定一个数组,里面全是正整数。数字大小表示这一步最多可以向后移动几个节点。总 //是从数组第一个元素开始移动。问如何移动,可以以最少步数移...
  • qq_36834069
  • qq_36834069
  • 2017-07-17 11:37:08
  • 431

给定一个数组,判断从开始能否走到结束,最多需要几步?

给定一个非负数组,数组中的元素代表从当前位置可以向后跳几步,求出从数组开始到末尾最少可以跳几次。例如:A = [2,3,1,1,4],则最少需要2步,2–>3–>4。 1、最直观,递归 pu...
  • guoyuguang0
  • guoyuguang0
  • 2016-03-24 18:52:33
  • 670

迷宫问题(广度优先搜索,输出最短路径)

Sample Input 15 16 .**.***.***.*** ***.***..**.*.* .**.***.***.*** ***.***..**.*.* **.***.***.***...
  • qq920444182
  • qq920444182
  • 2017-09-19 18:55:42
  • 362

图的广度优先搜索来求从一个城市到另一个城市的路径及其所经过城市最少

已知若干个城市的地图,求从一个城市到另一个城市的路径,要求路径中经过的城市最少 如上图所示表示从城市A到城市H的交通图,从图中要找到一条从城市A到城市H要经过城市最少的一条路线。 ...
  • pcjackson
  • pcjackson
  • 2017-04-25 22:46:35
  • 349
收藏助手
不良信息举报
您举报文章:有自己的代码--题目:给定一个数组,里面全是正整数。数字大小表示这一步最多可以向后移动几个节点。总是从数组第一个元素开始移动。问如何移动,可以以最少步数移动到最后一个节点。
举报原因:
原因补充:

(最多只允许输入30个字)