Question

我最近接受了微软的实习采访，我在面试中被问到这个问题。

它基本上就像，你有两个平行的楼梯，两个楼梯都有n个台阶。你从底部开始，你可以在任何一个楼梯上向上移动。楼梯上的每一步都附有罚款。您还可以通过其他一些惩罚移动两个楼梯。

我必须找到达到顶峰的最低罚款。

我尝试写一个递归关系，但由于变量太多，我无法写任何东西。

我最近读过有关动态编程的内容，我认为这个问题与此有关。

通过一些谷歌搜索，我发现这个问题与

相同

https://www.hackerrank.com/contests/frost-byte-final/challenges/stairway

您能为这个问题提供解决方案或方法吗？

Answer 1

创建两个数组以跟踪到达每个位置的最低成本。使用大量数字（例如1000000000）填充两个数组，并以第一步的成本填充数组的开头。

然后迭代所有可能的步骤，并使用内部循环迭代所有可能的跳转。

foreach step in (0, N) {
    // we're now sure we know minimal cost to reach this step
    foreach jump in (1,K) {
        // updating minimal costs here
    }
}

现在每次到达updating时，都有4种可能的行动要考虑：

从A [step]到A [step + jump]
从A [step]到B [step + jump]
从B [step]到A [step + jump]
从B [step]到B [step + jump]

对于每个动作，您都需要计算成本。因为您已经知道达到A [步骤]和B [步骤]的最优成本很容易。我们无法保证这一新举措是一项改进，因此如果新成本低于已经存在的成本，则只更新阵列中的目标成本。

Answer 2

这不仅仅是有向图搜索吗？任何一种简单的寻路算法都可以解决这个问题。参见

确保你强制执行楼梯方向（仅限上行）并考虑罚款（边缘权重）。

Worked solution

当然，你可以用动态编程来做到这一点，但我不是那个要求它的人......

Answer 3

导入java.io. ; 导入java.util。;

公共类主要{

public static int csmj(int []a,int src,int[] dp){
     
     if(src>=a.length){
         return Integer.MAX_VALUE-1;
     }
     
     
     if(src==a.length-1){
         return 0;
     }   
     
     if(dp[src]!=0){
         return dp[src];
     }

        int count=Integer.MAX_VALUE-1;
        for(int i=1;i<=a[src];i++){
            
            count = Math.min( count , csmj(a,src+i,dp)+1 );
        }
        
        dp[src] = count;
        
        return count;
}

public static void main(String args[] ) throws Exception {
   
    Scanner s = new Scanner(System.in);
    int n = s.nextInt();
    int a[] = new int[n];
    for(int i=0;i<n;i++){
        a[i] = s.nextInt();
    }
    
    int minJumps = csmj(a,0,new int[n]); 
    System.out.println(minJumps);

}

}

兄弟，您可以看看该解决方案，我的直觉是

爬楼梯所需的最小跳跃次数

3 个答案:

Worked solution