[Algorithm -- Dynamic Programming] Recursive Staircase Problem

For example there is a staricase

　　　　　　N = 3

                 | ---|

　　　  |---|　   |

     |---|            |

---|                  |

There is N = 3 staricase, for each step, you can either take {1 or 2} step at a time. So asking how many ways you can get on N = 3 step:

Answer: should be 3 ways: {1,1,1,}, {1,2}, {2,1}.

Now assue N=0, there is only 1 way, writing a function which takes number N and return the number of ways to get on Nth step.

Solution: The solution can involve recursion. We can use Dynamice programming, bottom up approach:

function num_ways_bottom_ip(n) {
  let nums = [];

  if (n === 0 || n === 1) {
    return 1;
  }
  nums[0] = nums[1] = 1;
  for (let i = 2; i <= n; i++) {
    nums[i] = nums[i - 1] + nums[i - 2];
  }

  return nums[n];
}

console.log(num_ways_bottom_ip(5)); // 8

This now takes O(N * |X|) time and O(N) space. X is the step allow to take , in our case, is 2.

Now if the requirements changes form only take {1, 2} steps, to you can take {1,3,5} each at a time; How you could solve the problem;

The idea is pretty similar to {1,2} steps. 

nums(i) = nums(i-1) + nums(i-2):

Therefore for {1.3.5} is equals:

nums(1) = nums(i-1) + nums(i-3) + nums(i-5)

We just need to make sure i-3, i-5 should be greater than 0.

function num_ways_bottom_up_X(n, x) {
  let nums = [];

  if (n === 0) {
    return 1;
  }
  nums[0] = 1;

  for (let i = 1; i <= n; i++) {
    let total = 0;
    for (let j of x) {
      if (i - j >= 0) {
        total += nums[i - j];
      }
    }
    nums[i] = total;
  }

  return nums[n];
}

console.log(num_ways_bottom_up_X(5, [1,3,5])); // 5