Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

climbStairs #1819

Closed
wants to merge 6 commits into from
Closed

climbStairs #1819

wants to merge 6 commits into from

Conversation

ananydev
Copy link
Contributor

@ananydev ananydev commented Nov 9, 2024

Climbing Stairs Problem
This program provides a solution to the "Climbing Stairs" problem, a classic example of dynamic programming. The problem can be stated as follows:

Problem Statement:
A person is at the bottom of a staircase with n steps and wants to reach the top. They can take either 1 or 2 steps at a time. The task is to determine the number of distinct ways the person can reach the top of the staircase.

Approach:s
Dynamic Programming

This problem has overlapping subproblems, making it a suitable candidate for dynamic programming.
Define dp[i] as the number of ways to reach the i-th step.
The number of ways to reach step i is the sum of ways to reach the previous step i-1 and the step before that, i-2. This is because the person can arrive at step i by taking a single step from i-1 or a double step from i-2.
Thus, the recurrence relation is:

𝑑𝑝[𝑖]=𝑑𝑝[𝑖−1]+𝑑𝑝[𝑖−2]dp[i]=dp[i−1]+dp[i−2]
Base Cases:

If there are no steps (n = 0), there is 1 way (doing nothing).
If there is one step (n = 1), there is also 1 way to reach it.
Building the Solution:

Create an array dp of size n+1 to store the number of ways to reach each step up to n.
Initialize dp[0] = 1 and dp[1] = 1 as per the base cases.
Use a loop to fill the array from dp[2] up to dp[n] using the recurrence relation.
Finally, dp[n] will contain the number of distinct ways to reach the top of the staircase with n steps.
Example:
For n = 5, the program calculates the ways as follows:

dp[0] = 1
dp[1] = 1
dp[2] = dp[1] + dp[0] = 2
dp[3] = dp[2] + dp[1] = 3
dp[4] = dp[3] + dp[2] = 5
dp[5] = dp[4] + dp[3] = 8
So, there are 8 distinct ways to reach the 5th step.

Complexity Analysis:
Time Complexity: O(n) because we only need to compute each value in dp from 0 to n.
Space Complexity: O(n) for storing the dp array.
This dynamic programming approach efficiently computes the number of ways to climb the staircase, demonstrating how overlapping subproblems and optimal substructure can be leveraged to solve problems effectively.

@ananydev
Copy link
Contributor Author

ananydev commented Nov 9, 2024

solved issue #1710

@ananydev
Copy link
Contributor Author

ananydev commented Nov 9, 2024

@pankaj-bind kindly review it asap . kindly elaborate if there is any issue

@ananydev ananydev closed this Nov 9, 2024
@pankaj-bind
Copy link
Member

Why did you close this PR?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

2 participants