An Introduction to Recursion笔记

在TopCoder中的Algorithm Tutorial看到一套讲解递归的文章：

An Introduction to Recursion, Part 1

An Introduction to Recursion, Part 2

感觉很不错，做一下笔记：

Some key considerations in designing a recursive algorithm:

1. It handles a simple "base case" without using recursion.
   In this example, the base case is "HelloWorld(0)"; if the function is asked to print zero times then it returns without spawning any more "HelloWorld"s.
2. It avoids cycles.
   Imagine if "HelloWorld(10)" called "HelloWorld(10)" which called "HelloWorld(10)." You'd end up with an infinite cycle of calls, and this usually would result in a "stack overflow" error while running. In many recursive programs, you can avoid cycles by having each function call be for a problem that is somehow smaller or simpler than the original problem. In this case, for example,count will be smaller and smaller with each call. As the problem gets simpler and simpler (in this case, we'll consider it "simpler" to print something zero times rather than printing it 5 times) eventually it will arrive at the "base case" and stop recursing. There are many ways to avoid infinite cycles, but making sure that we're dealing with progressively smaller or simpler problems is a good rule of thumb.（这个例子还不能凸显出这条consideration的重要性，但是后面的例子就凸显了： “And from B3, we'll consider B2 again. This will continue on until we error out: there's an infinite cycle.”，“ Looking at the above function, our base cases (0 and 1) are clear, and it's also clear thatn gets smaller with each call (and thus we shouldn't have problems with infinite cycles this time).”。
3. Each call of the function represents a complete handling of the given task.
   Sometimes recursion can seem kind of magical in the way it breaks down big problems. However, there is no such thing as a free lunch. When our function is given an argument of 10, we print "Hello World!" once and then we print it 9 more times. We can pass a part of the job along to a recursive call, but the original function still has to account for all 10 copies somehow.

Using a Memo

求曼波那契数列的n项：

function fib(n)
{
    declare variable i,memo[n]
    
    for each i from 0 to n
    {
        memo[i]=-1
    }
    memo[0]=0
    memo[1]=1

    return calcFibonacci(n,memo)
}

function calcFibonacci(n,memo)
{
    // If we've got the answer in our memo, no need to recalculate
    if memo[n]!=-1 then return memo[n]

    // Otherwise, calculate the answer and store it in memo    
    memo[n] = calcFibonacci(n-2,memo) + calcFibonacci(n-1,memo)

    // We still need to return the answer we calculated
    return memo[n]
}

Often, using a memo is as simple as looking at the input parameters, creating amemo array that corresponds to those input parameters, storing calculated values at the end of the function, and checking the memo as the function starts. Sometimes the input parameters won't be simple integers that map easily to amemo array - but by using other objects (like a hash table) for thememo we can continue with the same general pattern. In general, if you find a recursive solution for a problem, but find that the solution runs too slowly, then the solution is often memoization.