Scala 函数式编程语言中的棒切割

我试着用函数式编程语言实现优先记忆的棒切割问题，同时尝试尊重不变性，但我不知道如何才能做到这一点。文中给出了切杆问题的算法

memoized-cut-rod(p, n)
let r[0..n] be a new array
for i = 0 to n
    r[i] = -infinity
return memoized-cut-rod-aux(p, n, r)

memoized-cut-rod-aux(p, n, r)
if r[n] >= 0
    return r[n]
if n == 0
    q = 0
else
    q = -infinity
    for i = 1 to n
        q = max(q, p[i] + memoized-cut-rod-aux(p, n - i, r))
    r[n] = q
return q

---

有人能帮我得到一个纯函数的方法来实现这个算法吗

下面是自顶向下算法到Scala的一个翻译。记忆值是

memoizedCutRod

的本地值，因此它们对环境没有影响，即没有副作用。我改了几个名字。内部递归函数使用外部函数中的

p

，因为它没有改变，

memo

在递归函数的所有实例中共享

我还将

-infinity

的用法改为

选项[Int]

，这样我们就有了一个明确的指标，表明该值尚未定义。我更喜欢使用“不可能”数字作为标志的方法

def memoizedCutRod(p: Array[Int], n: Int): Int = {
  val memo = new Array[Option[Int]](n+1)
  (0 to n).foreach(memo(_) = None)

  def memoizedCutRodAux(n: Int): Int = {
    if ( memo(n).isDefined ) memo(n).get
    else if ( n == 0 ) 0
    else {
      val q = (1 to n).map(i => p(i) + memoizedCutRodAux(n - i)).max
      memo(n) = Some(q)
      q
    }
  }

  memoizedCutRodAux(n)
}

---

我尽了最大努力使它完全实用。希望它能满足你

type P = Seq[Int]
type R = Seq[Option[Int]]
type M = (Int, R)
type N = (P, M)
type ~>[A, B] = PartialFunction[A, B]

val r: Int => R = Seq.fill(_)(None)

val exists: N ~> M = {
  case (_, (n, r)) => 
    r(n).fold(throw new MatchError)((_, r))
}

val zero: N ~> M = {
  case (_, (n, r)) if n == 0 =>
    (0, r.updated(n, Some(0)))
}

val other: (N => M, N) => M = {
  case (f, (p, (n, r))) =>
    ((0, r) /: (1 to n)) {
      case ((q, r), i) =>
        val (q1, r1) = f(p, (n - i, r))
        (math.max(q, q1), r1)
    }
}

val cut: N ~> M = exists orElse zero orElse {
  case n: N => other(cut, n)
}

---

你能给我们一些关于算法的网页吗？它可以在这个链接上找到-@ryoichirookaka你能描述一下算法吗？这样这个问题在这个链接停止工作后会有意义吗？@user3749140我可以看到一个改进的算法写在你提到的算法之后。你会用它来代替吗？纯粹的功能性，你的意思是数组

r

是不可变的吗？或者你的意思是用

valq=（1到n）.map（i=>p（i）+memorizedcutrodaux（p，n-i，r））.max之类的东西替换递归步骤？