First recursive formulation

Is Harry at the same location as the cup? If so, return success.
Check if Harry can move one step north. If so, recursively solve the maze from one step north. If this recursive call succeeds, then we succeed.
Check if Harry can move one step south. If so, recursively solve the maze from one step south. If this recursive call succeeds, then we succeed.
Repeat for east and west.
If none of the (up to four) recursive calls succeeded, then fail.

Let's run through this idea with the sample maze from earlier, repeated here:

.#
.C
H#

Harry begins at (2, 0) (remember this is row=2, col=0), so we begin by calling solve(2, 0). The cup is not at (2, 0), so we try solving one from step north (make a recursive call at (1, 0)). The cup is not at (1, 0), so again we recursively solve from one step north, so we make a recursive call at (0, 0). Again, the cup isn't at (0, 0), so we try going north, but that isn't possible (because we would walk off the end of the maze). We try south, but that's where we just came from, so that isn't a good idea. We try east and west, but those are both blocked. So it turns out (0, 0) is a dead end. So far this is a diagram of our recursive calls:

solve(2, 0)
|
+--> solve(1, 0)
     |
     +--> solve(0, 0)
          |
          +--> failure (because we can't move anywhere)

So when solve(0, 0) returns failure, we will automatically backtrack to (1, 0):

solve(2, 0)
|
+--> solve(1, 0)
     |
     +--> solve(0, 0)
     |    |
     |    +--> failure
     |
     +--> what now?

What is the second recursive case in (1, 0)? We need to try south. But south from (1, 0) is where we arrived at (1, 0) from, so that makes no sense. Let's try east:

solve(2, 0)
|
+--> solve(1, 0)
     |
     +--> solve(0, 0)
     |    |
     |    +--> failure 
     |
     +--> solve(1, 1)

We've found the cup, so return success!

solve(2, 0)
|
+--> solve(1, 0)
     |
     +--> solve(0, 0)
     |    |
     |    +--> failure
     |
     +--> solve(1, 1)
          |
          +--> success (because we found the cup here)

solve(1, 1) returns success back to solve(1, 0):

solve(2, 0)
|
+--> solve(1, 0)
     |
     +--> solve(0, 0)
     |    |
     |    +--> failure
     |
     +--> solve(1, 1)
     |    |
     |    +--> success
     |
     +--> return success (because at least one recursive call was successful)

solve(1, 0) returns success back to solve(2, 0):

solve(2, 0)
|
+--> solve(1, 0)
|    |
|    +--> solve(0, 0)
|    |    |
|    |    +--> failure
|    |
|    +--> solve(1, 1)
|    |    |
|    |    +--> success
|    |
|    +--> return success 
|
+--> return success (because at least one recursive call was successful)

And therefore the original recursive call so solve(2, 0) returns success, indicating the cup was found successfully.

If this makes sense, go back to the previous page and continue.