Possibilities of Climbing n stairs with a constraint on the 20th floor

Question

Im solving a recursion problem in which the function int stairs(int n) returns the number of possibilities in climbing the stairs up to n, with the conditions of either taking 1 step or 2 steps. The following code solves this:

int stairs(int n)
{
   if (n<0) return 0;
   if (n==0) return 1;
   return stairs(n-1) + stairs(n-2);
}

Now i have a constraint that says: if you reach the 20th floor, you MUST use an elevator which takes you automatically all the way up to the n'th floor. If for some reason you skip level 20 (for instance, get to level 19 and then climb 2 floors to level 21), continue as usual. Find the number of possibilities for the constraint above. What I've done so far is this:

int stairs20(int n)
{
    if (n<=20) return stairs(n);
    return stairs(20) + stairs(n-21);
}

The logic behind the code is to calculate the number of possibilities in reaching the 20th floor, and the number of possibilities from the 21st floor and up. I presume this does not retrieve the correct answer and would appreciate advice on where is my mistake or what am I not calculating?

ask yourself this: which levels have special rules? then write the logic for them. — Karoly Horvath, Dec 17 '14 at 11:27
NOTE: `int` cannot store such large values. remember, it's the fibonacci sequence. — Karoly Horvath, Dec 17 '14 at 11:53
You're better off storing the results in an array, rather than calculating them over and over again: `stairs[n] = stairs[n-2] + stairs[n-1];` and so on. — TheBigH, Dec 17 '14 at 12:19

justmscs · Accepted Answer · 2014-12-17T11:52:56.513

5

When n>20,

you can first reach 20th floor, then go all the way up => stairs(20)
you can also reach 19th floor, then go to 21st floor, from 21st floor, you have stairs(n-21) ways to floor n, so => stairs(19)*stairs(n-21)

So sum it up is stairs(20) + stairs(19) * stairs(n-21).

You may use dynamic programming to avoid calculating the same value.

edited Dec 17 '14 at 11:52

answered Dec 17 '14 at 11:29

justmscs

756
4
12

Welcome, but you would better store what you have computed. – justmscs Dec 17 '14 at 11:52

score 2 · Answer 2 · answered Dec 17 '14 at 11:54

The basic recursion scheme is the following

int stairs(unsigned int n) {
    if (n < 2)
        return 1;
    return stairs(n-1) + stairs(n-2);
}

Now, the question you must ask yourself is how the rule applied to stair 20 will modify the recursion scheme ? If n > 20, then stairs(n) will be equal to stairs(20) + <number_of_ways_to_climb_to_n_without_reaching_floor20). How do you avoid floor 20 ? By reaching floor 19 and going straight to floor 21. Then, at floor 21, you must climb until you get to floor n. There are thus stairs(19)*stairs(n-21) to reach floor n without stopping at floor 20.

The final answer is therefore :

int stairs20(unsigned int n) {
    if(n > 20) {
        return stairs(20) + stairs(19)*stairs(n-21);
    } else {
        return stairs(n);
    }
}

Possibilities of Climbing n stairs with a constraint on the 20th floor

2 Answers2