You could go half-way, though. Recurse on rows, iterate on columns. Thinking about it, though, consider the following functions:

def emptyCosts(s: String) = List.range(0, s.length + 1)

def aboveCosts(costs: List[Int]) = cost map (_ + 1)

def diagCosts(costs: List[Int], c: Char, row: Int, s: String) = row +: (s zip costs).map {
case (a, n) if a == c => n
case (_, n) => n + 1
}

def sideCosts(costs: List[Int]) = costs.tail.foldLeft(List(costs.head)){
case (left :: others, cost) => cost.min(left + 1) :: left :: others
} reverse

def lineCosts(costs: List[Int], c: Char, row: Int, s: String) = sideCosts(aboveCosts(costs) zip diagCosts(costs, c, row, s) map Function.tupled(_ min _))

def ld(s1: String, s2: String) = s1.zipWithIndex.foldLeft(emptyCosts(s2)) {
case (costs, (c, row)) => lineCosts(costs, c, row + 1, s2)
} last

It can be made more efficient with Scala 2.8′s “zipped”, and with judicious use of an iterator or view.

At any rate, the previous line is used to compute the diagonal cost and the above cost, so that’s the point of recursion. To compute the ld(s1, s2), compute ld(s1.take(s1.length – 1), s2), use that to compute diagonal and above costs. Get the minimum between these two, and then call sideCost to compute/optimize costs from the left. SideCost can be made recursive too.

If s1 is empty, call emptyCost instead.

Once the recursive function is done, get the last element of the list that was computed.

Implementing this recursive version is left as an exercise for the reader of the comments, but it should avoid having to memoize anything or perform badly. :-)

It won’t be tail-recursive, though. I wonder what would happen if one used Stream instead of List, however.

That was a thought-provoking post!