js算法-动态规划-美团2020前端笔试-迷宫寻路

题目

如图：

 代码（JS(V8)的输入输出）

let MN=readline()
let MNlines=MN.split(' ')
let M=parseInt(MNlines[0])
let N=parseInt(MNlines[1])
let line
let info=new Array(M)//M表示数组长度
let rownum=0
while(line=readline()){
    let lines=line.split(' ')
    let infos=new Array(N)
    for(let i=0;i<N;i++){
        infos[i]=parseInt(lines[i]) //分别生成[1,3,1],[1,5,1],[4,2,1]
    }
    info[rownum]=infos //生成[[1,3,1],[1,5,1],[4,2,1]]
    rownum++
}
let TwoDimArray=new Array(M)
for(let i=0;i<TwoDimArray.length;i++){
    TwoDimArray[i]=info[i]
}
let Answer=(new Array(M)).fill(0).map(()=>(new Array(N)).fill(0))
//这段代码的意思是创建一个二维数组 Answer，其大小为 M 行 N 列，并且所有元素都被初始化为 0。
function FindBestWay(M,N,TwoDimArray){
    for(let i=0;i<M;i++){
        for(let j=0;j<N;j++){
            if(i!=0&&j!=0){
                Answer[i][j]=Math.min(Answer[i-1][j]+TwoDimArray[i][j],Answer[i][j-1]+TwoDimArray[i][j])
            }else if(i==0&&j!=0){
                Answer[i][j]=Answer[i][j-1]+TwoDimArray[i][j]
            }else if(i!=0&&j==0){
                Answer[i][j]=Answer[i-1][j]+TwoDimArray[i][j]
            }else{
                 Answer[0][0]=TwoDimArray[0][0]
            }
        }
    }
    return Answer[M-1][N-1]
}
let an=FindBestWay(M,N,TwoDimArray)
console.log(an)

解读

这段代码的作用是读取输入并计算最佳路径。

首先，通过 readline() 函数读取一行输入，将其存储在变量 MN 中。然后，使用 split(' ') 方法将 MN 字符串按空格分割成一个数组 MNlines，其中第一个元素表示 M，第二个元素表示 N。接着，使用 parseInt() 函数将 M 和 N 转换为整数类型，并分别存储在变量 M 和 N 中。

接下来，定义变量 line，用于存储后续的输入行。然后，创建一个长度为 M 的数组 info，用于存储后续输入行的数据。定义变量 rownum 并初始化为 0，用于追踪当前行数。

在接下来的循环中，使用 readline() 函数读取输入的每一行，将其存储在变量 line 中。然后，使用 split(' ') 方法将 line 字符串按空格分割成一个数组 lines，其中每个元素表示当前行的一个数字。接着，创建一个长度为 N 的数组 infos，用于存储当前行的数字。使用 parseInt() 函数将 lines 数组中的每个元素转换为整数，并存储在 infos 数组中。最后，将 infos 数组赋值给 info 数组的第 rownum 行。

接下来，创建一个长度为 M 的数组 TwoDimArray，用于存储 info 数组的数据。通过一个循环，将 info 数组的每一行赋值给 TwoDimArray 数组的对应位置。

然后，创建一个大小为 M 行 N 列的二维数组 Answer，并将所有元素初始化为 0。

接下来，定义了一个名为 FindBestWay 的函数，该函数接受参数 M、N 和 TwoDimArray。在函数内部，使用两个嵌套的循环遍历二维数组 Answer 的每个元素。根据当前元素的位置，使用动态规划的思想计算最佳路径的值，并将结果存储在 Answer 数组中。

在这个题目中，动态规划的思想是通过构建一个二维数组 Answer 来解决问题。该数组的大小为 M 行 N 列，其中 Answer[i][j] 表示从起点到达位置 (i, j) 的最佳路径的值。

动态规划的核心思想是利用已经计算过的子问题的解来求解更大规模的问题。在这个题目中，我们可以利用已经计算过的路径值来计算更大规模的路径值。

具体实现如下：

1. 首先，我们初始化 Answer 数组的第一个元素 Answer[0][0] 为起点的值 TwoDimArray[0][0]。
2. 然后，我们使用两个嵌套的循环遍历 Answer 数组的每个元素，从左上角开始，逐行逐列计算最佳路径的值。
3. 对于每个位置 (i, j)，我们考虑两种情况：
   • 如果 i 和 j 都不等于 0，即不在第一行和第一列，那么最佳路径的值可以通过从上方 (i-1, j) 或左方 (i, j-1) 的位置到达当前位置 (i, j)，并选择路径值较小的那个，再加上当前位置的值 TwoDimArray[i][j]。
   • 如果 i 等于 0 且 j 不等于 0，即在第一行但不在第一列，那么最佳路径的值只能通过左方 (i, j-1) 的位置到达当前位置 (i, j)，再加上当前位置的值 TwoDimArray[i][j]。
   • 如果 i 不等于 0 且 j 等于 0，即在第一列但不在第一行，那么最佳路径的值只能通过上方 (i-1, j) 的位置到达当前位置 (i, j)，再加上当前位置的值 TwoDimArray[i][j]。
   • 如果 i 和 j 都等于 0，即在起点位置，那么最佳路径的值就是起点的值 TwoDimArray[0][0]。
4. 最后，返回 Answer[M-1][N-1]，即终点位置的最佳路径值。

通过这种动态规划的思想，我们可以避免重复计算，并且利用已经计算过的子问题的解来求解更大规模的问题，从而得到最佳路径的值。