array专题2---理解暴力枚举与动态规划

746 Min Cost Climbing Stairs

一直以后对暴力枚举（又称：深度优先搜索）和动态规划不太理解，不能明白个中区别，更别说贪心。今天做这道题目的时候有点心得。
思路一：看到题目，直觉告诉我暴力枚举可以。每遇到一个台阶i，我可以花费cost[i]跳过去，也可以花费cost[i+1]直接跳到i+1台阶，也相当于跳过i台阶了。我就用这种方式，不断跳过最后一个台阶n，到达n+1级台阶。

public int minCostClimbingStairs(int[] cost) {
        minCost = Integer.MAX_VALUE;
        visit(cost,0,0,true);
        return minCost;

    }

    private void visit(int[] cost, int curStep,int curCost,boolean skip) {
        if(curStep == cost.length-1){
            if(!skip){
                curCost += cost[curStep];
            }
            curStep++;
        }
        if(curStep>=cost.length){
            minCost = Math.min(curCost, minCost);
            return;
        }
        //花费代价跳过这个台阶，下一个台阶就允许直接跳过
        visit(cost,curStep+1,curCost+cost[curStep],true);
        if(skip){
            //不花费代价跳过这个台阶，下一个台阶就必须付出代价
            visit(cost,curStep+1,curCost,false);
        }
    }

思路二：动态规划是从最终目的着手。最终目的是要跳到下标为n的级台阶，从0开始计算。那么跳到n级台阶的代价与n-1级台阶有什么关系呢？找到子问题与原问题的关系式，这就是与暴力搜索不一样的地方，暴力搜索按照题目意思可以直接写代码。到达第i级台阶的代价：dp[i] = min(dp[i-2] + cost[i-2], dp[i-1] + cost[i-1])。i从0,1开始，dp[0]=0,dp[1]=0。

    public int minCostClimbingStairsV2(int[] cost) {
        return dpcost(cost.length ,cost);
    }

    private int dpcost(int n,int[] cost){
        if(n==0 || n==1){
            return 0;
        }
        return Math.min(dpcost(n-2,cost)+cost[n-2], dpcost(n-1,cost)+cost[n-1]);
    }

下一个版本是对动态规划做改进。当n=5的时候会计算dpcost(3),dpcost(4)，当n=4的时候会计算dpcost(2),dpcost(3)，dpcost(3)计算了两次，用数组存起来。当然也可以用两个变量存一下，更节省空间。

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