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

Climbing Stairs Problem #1823

Merged
merged 9 commits into from
Nov 9, 2024
Merged

Climbing Stairs Problem #1823

merged 9 commits into from
Nov 9, 2024

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.

Copy link
Member

@pankaj-bind pankaj-bind left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

{FDAB7886-9E2B-4434-A550-4104A732B96A}
delete one of the folder

@ananydev
Copy link
Contributor Author

ananydev commented Nov 9, 2024

@pankaj-bind kindly check now

@ananydev
Copy link
Contributor Author

ananydev commented Nov 9, 2024

@pankaj-bind kindly merge this pr now

@pankaj-bind pankaj-bind merged commit 0cb932e into AlgoGenesis:main Nov 9, 2024
1 of 2 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

Successfully merging this pull request may close these issues.

2 participants