F# F中的二维动态规划#

我需要在F#中的2D中实现一个简单的动态规划算法。对于简单的1D案例，如下展开似乎是可行的方法，请参见

是否有一种很好（且有效）的方法可以在2D中实现类似的结果，例如，以函数式方式重写以下伪代码：

  let alpha = 
    let result = Array2D.zeroCreate N T
    for i in 0 .. N-1 do
      result.[0, i] <- (initialPi i) * (b i observations.[0])
    for t in 1 .. T-1 do
      for i in 0 .. N-1 do
        let s = row t-1 result |> Seq.mapi (fun j alpha_t_j -> alpha_t_j * initialA.[i, j]) () |> Seq.sum
        result.[t, i] <- s * (b i observations.[t])
    result 

let alpha=
让结果=Array2D.zeroCreate N T
因为我在0。。N-1do
结果[0，i]Seq.mapi（fun j alpha___j->alpha__j*首字母[i，j]）（）Seq.sum
结果。[t，i]EDIT：实际读取代码，这至少是功能性的，返回类型略有不同，不过可以通过转换避免这种情况

let alpha = 
    let rec build prev idx max = 
        match idx with
        |0 -> 
            let r = (Array.init N (fun i -> (initialPi y) * (b i observations.[0]))
            r:: (build r 1 max)
        |t when t=max -> []
        |_ ->  
             let s = prev |> Seq.mapi (fun j alpha_t_j -> alpha_t_j * initialA.[i, j]) () |> Seq.sum
             let r = Array.init N (fun i -> s * (b i observations.[t]))
         r:: build r (idx+1 max)
    build [] 0 T |> List.toArray       

编辑：实际读取代码，这至少是功能性的，返回类型略有不同，尽管您可以通过转换避免这种情况

let alpha = 
    let rec build prev idx max = 
        match idx with
        |0 -> 
            let r = (Array.init N (fun i -> (initialPi y) * (b i observations.[0]))
            r:: (build r 1 max)
        |t when t=max -> []
        |_ ->  
             let s = prev |> Seq.mapi (fun j alpha_t_j -> alpha_t_j * initialA.[i, j]) () |> Seq.sum
             let r = Array.init N (fun i -> s * (b i observations.[t]))
         r:: build r (idx+1 max)
    build [] 0 T |> List.toArray       

@Grzenio这将返回该数组-整个过程是一个巨大的数组创建函数，因此我不需要命名它，我理解，但是在第二个匹配案例中，您提到的是
结果
，它在您的版本中未定义（它过去是在我的命令式版本中创建的数组）@Grzenio抱歉，错过了这一点，我会设法解决的it@Grzenio这将返回该数组-整个过程是一个巨大的数组创建函数，因此我不需要命名它。我理解，但在第二个匹配案例中，您引用的是
结果
，它在您的版本中未定义（它以前是在我的命令式版本中创建的数组）@Grzenio抱歉，错过了这一点，我会设法解决的你重写这篇文章的动机是什么？只是为了教育目的吗？看起来上面的阵列版本将是您生产的最佳选择。您重写此版本的动机是什么？只是为了教育目的吗？看起来上面的阵列版本将是生产的最佳选择。。