描述

你需要爬上一個N層的樓梯,在爬樓梯過程中,每階樓梯需花費非負代價,第i階樓梯花費代價表示為cost[i],一旦你付出了代價,你可以在該階基礎上往上爬一階或兩階。你可以從第0階或者第1階開始,請找到到達頂層的最小的代價是多少
N和cost[i]皆為整數,且N∈[2,1000],cost[i]∈[0,999]

輸入

輸入為一行整數,對應cost陣列

輸出

輸出一個整數,表示花費的最小代價

輸入樣例 1 

1 100 1 1 1 100 1 1 100 1

輸出樣例 1

6
解釋: 最低花費方式是從cost[0]開始，逐個經過那些1，跳過cost[3]，一共花費6。

輸入樣例 2 

10 15  20

輸出樣例 2

15
解釋: 最低花費是從cost[1]開始，然後走兩步即可到階梯頂，一共花費15。

方法一：dp[i]中儲存的是到達i-1和i-2中最少的花費

例如樣例1：1 100 1 1 1 100 1 1 100 1

dp[0]和dp[1]是可以直接出發的點，所以在他們之前的最少花費為0.

dp[0]=0   dp[1]=0 ;

dp[2]中要儲存到達0和1中最少的花費：dp[0]+cost[0]=0+1=1, dp[1]+cost[1]=0+100=100, 所以dp[2]=1;

dp[3]中要儲存到達1和2中最少的花費：dp[1]+cost[1]=0+100=100, dp[2]+cost[2]=1+1=2, 所以dp[3]=2;

dp[4]中要儲存到達2和3中最少的花費：dp[2]+cost[2]=1+1=2, dp[3]+cost[3]=2+1=3, 所以dp[4]=2;

dp[5]中要儲存到達3和4中最少的花費：dp[3]+cost[3]=2+1=3, dp[4]+cost[4]=2+1=3, 所以dp[5]=3;

dp[6]中要儲存到達4和5中最少的花費：dp[4]+cost[4]=2+1=3, dp[5]+cost[5]=3+100=103, 所以dp[6]=3;

dp[7]中要儲存到達5和6中最少的花費：dp[5]+cost[5]=3+100=103, dp[6]+cost[6]=3+1=4, 所以dp[7]=4;

dp[8]中要儲存到達6和7中最少的花費：dp[6]+cost[6]=3+1=4, dp[7]+cost[7]=4+1=5, 所以dp[8]=4;

dp[9]中要儲存到達7和8中最少的花費：dp[7]+cost[7]=4+1=5, dp[8]+cost[8]=4+100=104, 所以dp[9]=5;

dp[10]中要儲存到達8和9中最少的花費：dp[8]+cost[8]=4+100=104, , dp[9]+cost[9]=5+1=6, 所以dp[10]=6;

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp=new int[10000];
        dp[0]=0;
        dp[1]=0;
        for(int i=2;i<cost.length+1;i++)
        {
            dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
       return dp[cost.length];
    }
}

方法二：dp[i]中儲存的是到達i的最低花費

dp[0]最低花費即為cost[0] , dp[1]最低花費即為cost[1].

dp[0]=1, dp[1]=100

dp[2] = dp[0]和dp[1]中的最低花費 + cost[2] = dp[0]+1=2

dp[3] = dp[1]和dp[2]中的最低花費 + cost[3] = dp[2]+1=3

dp[4] = dp[2]和dp[3]中的最低花費 + cost[4] = dp[2]+1=3

dp[5] = dp[3]和dp[4]中的最低花費 + cost[5] = dp[3]+100=dp[4]+100=103

dp[6] = dp[4]和dp[5]中的最低花費 + cost[6] = dp[4]+1=4

dp[7] = dp[5]和dp[6]中的最低花費 + cost[7] = dp[6]+1=5

dp[8] = dp[6]和dp[7]中的最低花費 + cost[8] = dp[6]+100=104

dp[9] = dp[7]和dp[8]中的最低花費 + cost[9] = dp[7]+1=6

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp=new int[10000];
        dp[0]=cost[0];
        dp[1]=cost[1];
        for(int i=2;i<cost.length;i++)
        {
            dp[i]=Math.min(dp[i-1],dp[i-2])+cost[i];
        }
       return Math.min(dp[cost.length-1],dp[cost.length-2]);
    }
}