动态规划3题

1、爬梯子问题（斐波那契数列）

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：

输入：n = 2
输出：2

示例 2：

输入：n = 7
输出：21

示例 3：

输入：n = 0
输出：1

/**
 * @param {number} n
 * @return {number}
 */
var numWays = function(n) {

    if(n<=1)
    {
        return 1;
    }
    
    var ways=[];
    ways[0]=1;
    ways[1]=1;
    for(i=2;i<n+1;i++)
    {
        ways[i] = (ways[i-1] + ways[i-2])%1000000007; //状态转移方程
    }
    return ways[n];
    
};

2、所有路径问题

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

var robot = function(m,n){

        var f = new Array(m+1);
        for(var i =0;i<m+1;i++){
            f[i] = new Array(n+1);
        }

        for(var i=0;i<m+1;i++)
        {
            f[i][0] = 0;
        }
        for(var i=0;i<n+1;i++)
        {
            f[0][i] = 0;
        }


        f[1][1]=1;
        
        for(var i=1;i<m+1;i++){
            for(var j=1;j<n+1;j++){
                if(i === 1 && j === 1){
                    continue;
                }

                f[i][j]=f[i-1][j]+f[i][j-1];//状态转移方程
            }
        }
        
        return f[m][n];
    }

    console.log(robot(7,3));

3、最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

示例: 输入:[ [1,3,1], [1,5,1], [4,2,1] ]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

var minWay = function(grid){

    var sum = new Array(grid.length)
    for(var i=0;i<grid.length;i++){
        sum[i] = new Array(grid[0].length);
    }

    sum[0][0] = grid[0][0];

    for(var i=0;i<grid.length;i++)
    {
        for(var j=0;j<grid[0].length;j++){
            if( i === 0 && j === 0){
                continue;
            }else if( i-1<0 ){
                sum[i][j] = sum[i][j-1] + grid[i][j];
            }else if( j-1<0 ){
                sum[i][j] = sum[i-1][j] + grid[i][j];
            }else{
                sum[i][j] = Math.min( sum[i-1][j] , sum[i][j-1]) +grid[i][j];
            }
        }
    }

    return sum[grid.length-1][grid[0].length-1];

    //sum[m][n]=Math.min(sum[m-1][n],sum[m][n-1])+grid[m][n];//状态转移方程
}


var grid = [
       [1,3,1],
       [1,5,1],
       [4,2,1]
   ]

console.log(minWay(grid));