question_slug stringlengths 3 77 | title stringlengths 1 183 | slug stringlengths 12 45 | summary stringlengths 1 160 ⌀ | author stringlengths 2 30 | certification stringclasses 2
values | created_at stringdate 2013-10-25 17:32:12 2025-04-12 09:38:24 | updated_at stringdate 2013-10-25 17:32:12 2025-04-12 09:38:24 | hit_count int64 0 10.6M | has_video bool 2
classes | content stringlengths 4 576k | upvotes int64 0 11.5k | downvotes int64 0 358 | tags stringlengths 2 193 | comments int64 0 2.56k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++ Bottom-Up DP | c-bottom-up-dp-by-votrubac-s1mf | Intuition\nThis is similar to 935. Knight Dialer.\n#### Catch\nThe array size can be larger than the number of steps. We can ingore array elements greater than | votrubac | NORMAL | 2019-11-24T07:02:11.838413+00:00 | 2019-11-25T01:44:26.649240+00:00 | 6,822 | false | #### Intuition\nThis is similar to [935. Knight Dialer](https://leetcode.com/problems/knight-dialer/discuss/189251/C%2B%2B-5-lines-DP).\n#### Catch\nThe array size can be larger than the number of steps. We can ingore array elements greater than `steps / 2`, as we won\'t able to go back to the first element from there.\n```\nint numWays(int steps, int arrLen) {\n int sz = min(steps / 2 + 1, arrLen);\n vector<int> v1(sz + 2), v2(sz + 2);\n v1[1] = 1;\n while (steps-- > 0) {\n for (auto i = 1; i <= sz; ++i)\n v2[i] = ((long)v1[i] + v1[i - 1] + v1[i + 1]) % 1000000007;\n swap(v1, v2);\n }\n return v1[1];\n}\n```\n**Complexity Analysis**\n- Time: O(n * min(n, m)), where n is the number of steps, and m - array size.\n- Memory: O(min(n, m)). | 66 | 0 | [] | 9 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 【Video】Give me 10 minutes - How we think abou a solution - Python, JavaScript, Java, C++ | video-give-me-10-minutes-how-we-think-ab-otts | Welcome to my post! This post starts with "How we think about a solution". In other words, that is my thought process to solve the question. This post explains | niits | NORMAL | 2023-10-15T03:30:17.116438+00:00 | 2023-10-16T17:22:33.246637+00:00 | 1,435 | false | Welcome to my post! This post starts with "How we think about a solution". In other words, that is my thought process to solve the question. This post explains how I get to my solution instead of just posting solution codes or out of blue algorithms. I hope it is helpful for someone.\n\n# Intuition\nWe only care about steps / 2\n\n---\n\n# Solution Video\n\nhttps://youtu.be/uC0nI4E7ozw\n\n\u25A0 Timeline of the video\n`0:04` How we think about a solution\n`0:05` Two key points to solve this question\n`0:21` Explain the first key point\n`1:28` Explain the second key point\n`2:36` Break down and explain real algorithms\n`6:09` Demonstrate how it works\n`10:17` Coding\n`12:58` Time Complexity and Space Complexity\n\n### \u2B50\uFE0F\u2B50\uFE0F Don\'t forget to subscribe to my channel! \u2B50\uFE0F\u2B50\uFE0F\n\n**\u25A0 Subscribe URL**\nhttp://www.youtube.com/channel/UC9RMNwYTL3SXCP6ShLWVFww?sub_confirmation=1\n\nSubscribers: 2,714\nMy initial goal is 10,000\nThank you for your support!\n\n---\n\n# Approach\n\n### How we think about a solution\n\nThis is a very simple solution. First of all, we have to come back to start position `index 0`, so the first thing that I came up with right after I read description is this.\n\n\n---\n\n\u2B50\uFE0F Points\n\nWe can move half length of input `steps` at most because we need some steps to go back to start position. In other words we don\'t have to care about input length of array greater than `steps / 2`.\n\n\n---\n\n- How we can calculate number of ways to each position.\n\nThis is also simple idea. The description says "you can move 1 position to the left, 1 position to the right in the array, or stay in the same place".\n\n\n---\n\n\u2B50\uFE0F Points\nCalculation of number of ways for current position is simply\n```\ncurrent position = a[postion] + a[postion - 1] + a[postion + 1]\n\na: array\nposition: stay\nposition - 1: from left side\nposition + 1: from righ side\n\n```\n\n---\n\nSince we need to keep current number of ways so far, seems like we can use dynamic programing.\n\n- How it works\n\nLet\'s see the key points with simple concrete example.\n\n```\nInput: steps = 2, arrLen = 4\n```\n\nFirst of all, we take max position where we can go by\n\n```\nmin(steps // 2 + 1, arrLen)\n= min(2 // 2 + 1, 4)\n= 2\n\n```\n- **why +1?**\n\nThe reason why we need `+1` is simply, this example gives us `2` steps, so we need `2` positions to calculate ways.\n\nWe start from `index 1`(we consider index 1 as start position(index 0) in arrays for dynamic programming). In that case, we can move until `index 2` which is half of steps, so we need `index 2` to check the ways.\n\n- **Why we start from `index 1`?**\n\nActually you can start from `index 0` but if you start from `index 1`, you don\'t have to check out of bounds in the loop.\n\n\nLook at these Python code.\n\n```\ncur_ways = [0] * (max_position + 2)\nnext_ways = [0] * (max_position + 2)\n```\n\nThat\'s because we will calcuate total of `stay`, `left`, `right` positions, so having two extra position enables us to write code easy. we don\'t have to check out of bounds in the loop.\n\n```\n0,1,2,3\n```\nIn this case, we really need `index 1` and `index 2` and we added `index 0` and `index 3` as extra `2` positions.\n\nSo, when we calculate start position(index 1), we can simply calculate \n\n```\nindex 0 + index 1 + index 2\n```\n\nNo need if statement or something.\n\n`index 3` is also the same idea when we calculate `index 2` and both sides of indices are always `0`, so they prevent out of bounds and doesn\'t affect result of calculation.\n\n---\n\n\u2B50\uFE0F Points\n\n- Having two extra positions will prevent us from out of bounds\n- the extra splace always 0 value, so they don\'t affect results of calculation.\n\n---\n\nWe will create two arrays(`cur_ways`, `next_ways`) and will update `next_ways`, then swap `next_ways` with `cur_ways`, because (current) next ways is the next current ways.\n\nWe check all positions from 1 to `max_position` by number of steps. I print `next_ways` variable. The first number is position(`pos`). \n\n\n\nIn the end if we have \n\n```\nInput: steps = 2, arrLen = 4\n```\n\n`next_way` will be updated like that, so we should return `2` at `index1`.\n\nI think the two ways are \n```\n"stay", "stay"\n"right", "left"\n\n```\nWe can\'t go "left", "right", because that is out of bounds. The description says "The pointer should not be placed outside the array at any time".\n\nLet\'s see a real algorithm!\n\n\n### Algorithm Overview:\nThe algorithm employs dynamic programming to calculate the number of ways to reach the starting position after a specified number of steps on an array of tiles.\n\n### Detailed Explanation:\n1. **Initialization**:\n - Calculate the maximum position (`max_position`) based on the minimum of half the steps plus one and the array length. This restricts the position within the array.\n - Initialize arrays `cur_ways` and `next_ways` of length `(max_position + 2)` and fill them with zeros. These arrays store the number of ways to reach each position.\n - Set `cur_ways[1]` to 1 since there\'s one way to start at position 1.\n - Define a variable `mod` to store the modulo value (`10^9 + 7`) for overflow prevention.\n\n2. **Dynamic Programming**:\n - Iterate through the steps, decrementing the count with each iteration.\n - For each step:\n - Iterate through each position from `1` to `max_position`.\n - Update `next_ways[pos]` using the rule: the sum of the number of ways from the previous step at the current position, the previous position, and the next position, all modulo `mod` to prevent overflow.\n - Swap `cur_ways` and `next_ways` to update the current ways for the next step.\n\n3. **Return Result**:\n - After the iterations, return the number of ways to reach the first position (`cur_ways[1]`) after the specified number of steps. This represents the total number of ways to reach the starting position.\n\n# Complexity\n- Time complexity: O(steps * min(steps // 2 + 1, arrLen))\n\n- Space complexity: O(steps)\n\n\n```python []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n max_position = min(steps // 2 + 1, arrLen)\n cur_ways = [0] * (max_position + 2)\n next_ways = [0] * (max_position + 2)\n cur_ways[1] = 1\n mod = 10 ** 9 + 7\n\n while steps > 0:\n for pos in range(1, max_position + 1):\n next_ways[pos] = (cur_ways[pos] + cur_ways[pos - 1] + cur_ways[pos + 1]) % mod\n\n cur_ways, next_ways = next_ways, cur_ways\n steps -= 1\n\n return cur_ways[1] \n```\n```javascript []\nvar numWays = function(steps, arrLen) {\n const maxPosition = Math.min(Math.floor(steps / 2) + 1, arrLen);\n let curWays = new Array(maxPosition + 2).fill(0);\n let nextWays = new Array(maxPosition + 2).fill(0);\n curWays[1] = 1;\n const mod = 10 ** 9 + 7;\n\n while (steps > 0) {\n for (let pos = 1; pos <= maxPosition; pos++) {\n nextWays[pos] = (curWays[pos] + curWays[pos - 1] + curWays[pos + 1]) % mod;\n }\n\n // Swap arrays using a temporary variable\n let temp = curWays;\n curWays = nextWays;\n nextWays = temp;\n steps--;\n }\n\n return curWays[1]; \n};\n```\n```java []\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int maxPosition = Math.min(steps / 2 + 1, arrLen);\n int[] curWays = new int[maxPosition + 2];\n int[] nextWays = new int[maxPosition + 2];\n curWays[1] = 1;\n int mod = 1000000007;\n\n while (steps > 0) {\n for (int pos = 1; pos <= maxPosition; pos++) {\n nextWays[pos] = (int)(((long)curWays[pos] + curWays[pos - 1] + curWays[pos + 1]) % mod);\n }\n\n int[] temp = curWays;\n curWays = nextWays;\n nextWays = temp;\n steps--;\n }\n\n return curWays[1]; \n }\n}\n```\n```C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int maxPosition = min(steps / 2 + 1, arrLen);\n vector<int> curWays(maxPosition + 2, 0);\n vector<int> nextWays(maxPosition + 2, 0);\n curWays[1] = 1;\n const int mod = 1000000007;\n\n while (steps > 0) {\n for (int pos = 1; pos <= maxPosition; pos++) {\n nextWays[pos] = ((long)curWays[pos] + curWays[pos - 1] + curWays[pos + 1]) % mod;\n }\n\n swap(curWays, nextWays);\n steps--;\n }\n\n return curWays[1]; \n }\n};\n```\n\n---\n\nThank you for reading my post.\n\u2B50\uFE0F Please upvote it and don\'t forget to subscribe to my channel!\n\n\u25A0 My next post and video for daily coding challenge\n\npost\nhttps://leetcode.com/problems/pascals-triangle-ii/solutions/4173366/video-give-me-10-minutes-how-we-think-about-a-solution-python-javascript-java-c/\n\nvideo\nhttps://youtu.be/1162hVzZ3sM\n\n\u25A0 Timeline of the video\n`0:04` Key point to solve this question\n`0:05` Two key points to solve this question\n`0:16` Actually there is a formula for Pascal\'s Triangle\n`0:32` Explain basic idea and the key point\n`2:38` Demonstrate real algorithms\n`6:39` Coding\n`7:43` Time Complexity and Space Complexity\n\n\u25A0 My previous post and video for daily coding challenge\n\npost\nhttps://leetcode.com/problems/min-cost-climbing-stairs/solutions/4162780/video-give-me-10-minutes-how-we-think-about-a-solution-python-javascript-java-c/\n\nvideo\nhttps://youtu.be/LopoDDa4dLY\n\n\u25A0 Timeline of the video\n\n`0:00` Read the question of Min Cost Climbing Stairs\n`1:43` Explain a basic idea to solve Min Cost Climbing Stairs\n`6:03` Coding\n`8:21` Summarize the algorithm of Min Cost Climbing Stairs\n\n | 39 | 0 | ['C++', 'Java', 'Python3', 'JavaScript'] | 3 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Step by Step Solution (diagrams) (with how I overcome Memory/Time limit exception) | step-by-step-solution-diagrams-with-how-fjlak | Hi guys, \nThe question is a lot easier to visualize when you think backwards. \nLets set N = steps, M = arrLen\nYou want to find how many possible ways you can | qwerjkl112 | NORMAL | 2019-11-24T04:46:13.762017+00:00 | 2019-11-24T05:14:34.847535+00:00 | 3,542 | false | Hi guys, \nThe question is a lot easier to visualize when you think backwards. \nLets set N = steps, M = arrLen\nYou want to find how many possible ways you can reach the array[0] at Nth step.\nLets ask ourselves, how do we find array[0] at N-1th step.\nSince we are given directions, Left, Stay, Right, we can just add the number of steps we have at N-1th step in array[0], array[1] (array[-1] isnt available)\nThis makes sense because at N-1 th step, we can stay in array[0] or we can move left in arr[1]\n\n0 [][][][]...\n1 [][][][]...\n2 [][][][]...\n.\n.\nN-1[X][Y][][]\nN [Z][][][]\n\nUsing the same intuition, we find N-2 th step, for array[0] and array[1]\nfor array[1] for N-1, we have to add array[0], array[1], array[2] together \nLeading us to the equation.\n```\ndp[N][M] = (dp[N-1][M-1] + dp[N-1][M] + dp[N-1][M+1]) // with boundary checks\n```\nex: steps = 4, arrLen = 4 // notice dp[0][0] will always be 1 since we start there.\n0 [1][0][0][0]\n1 [1][1][0][0]\n2 [2][2][1][0]\n3 [4][5][3][1]\n4 [9][12][9][4]\n\n\n\n```\nclass Solution {\n private final int MOD = 1000000007;\n public int numWays(int steps, int arrLen) {\n int[][] dp = new int[steps+1][arrLen];\n dp[0][0] = 1;\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j < arrLen; j++) {\n if (dp[i-1][j] > 0) {\n dp[i][j] = (dp[i][j] + dp[i-1][j]) % MOD;\n }\n if (j +1 < arrLen && dp[i-1][j+1] > 0) {\n dp[i][j] = (dp[i][j] + dp[i-1][j+1]) % MOD;\n }\n if (j -1 >= 0 && dp[i-1][j-1] > 0) {\n dp[i][j] = (dp[i][j] + dp[i-1][j-1]) % MOD;\n }\n }\n }\n return dp[steps][0]; \n }\n}\n```\nThis leads to a Memory Limit Exception due to Space O(M * N)\nNotice that for each new N, we only need infomation from N-1. This means we don\'t need to keep track of everything from 0,1,2,...N-2\nWe can optimize by simply using 2 arrays. \nThis reduces our Space Complexity to O(M)\n\n```\nclass Solution {\n private final int MOD = 1000000007;\n public int numWays(int steps, int arrLen) {\n int[] last = new int[arrLen];\n last[0] = 1;\n for (int i = 1; i <= steps; i++) {\n int[] curr = new int[arrLen];\n for (int j = 0; j < Math.min(steps, arrLen); j++) {\n if (last[j] > 0) {\n curr[j] = (curr[j] + last[j]) % MOD;\n }\n if (j+1 < arrLen && last[j+1] > 0) {\n curr[j] = (curr[j] +last[j+1]) % MOD;\n }\n if (j-1 >= 0 && last[j-1] > 0) {\n curr[j] = (curr[j] + last[j-1]) % MOD;\n }\n }\n last = curr.clone();\n }\n return last[0]; \n }\n}\n```\n\nThis unexpectly gave me a Time Limited Exceeded Exception last minute in the contest :\'( \nTake a second to spot the mistake \n.\n.\n.\n.\n.\n.\nIncase you didn\'t catch it, \n**it is this line last = curr.clone();**\nNoticed how I set the length to arrLen in the beginning.\nNow look at this test case steps = 500, arrLen = 969997\nThe timeout exception makes sense now. \n\nTo solve this, if we think logically about what steps mean, \nwe can see that the arrLen limited by the # of steps we have. This is beacuse if we move right on every step, the most we can can ever reach is Min(arrLen, steps) **arrLen can still be smaller than steps**\n\nUltimately, this leads me to this final solution\n\n```\nclass Solution {\n private final int MOD = 1000000007;\n public int numWays(int steps, int arrLen) {\n int[] last = new int[Math.min(steps, arrLen)+1];\n last[0] = 1;\n for (int i = 1; i <= steps; i++) {\n int[] curr = new int[Math.min(arrLen, steps)+1];\n for (int j = 0; j < Math.min(steps, arrLen); j++) {\n if (last[j] > 0) {\n curr[j] = (curr[j] + last[j]) % MOD;\n }\n if (j+1 < arrLen && last[j+1] > 0) {\n curr[j] = (curr[j] +last[j+1]) % MOD;\n }\n if (j-1 >= 0 && last[j-1] > 0) {\n curr[j] = (curr[j] + last[j-1]) % MOD;\n }\n }\n last = curr.clone();\n }\n return last[0]; \n }\n}\n```\n\nTime: O(N^2) //worst case arrLen > steps \nSpace: O(Min(N, M))\n\n*Please comment any improvements that I can make. I hope this helps you to prevent making the same mistakes I did :)* | 39 | 0 | [] | 5 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 7 python approaches with Time and Space analysis | 7-python-approaches-with-time-and-space-aovfr | APP1: DFS. Time: O(3^N) Space: O(1). \n# Result: TLE when 27, 7\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 o | rayfengli | NORMAL | 2020-04-08T16:35:47.001094+00:00 | 2020-05-27T11:38:06.742946+00:00 | 2,255 | false | # APP1: DFS. Time: O(3^N) Space: O(1). \n# Result: TLE when 27, 7\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n return self.dfs(steps, arrLen, 0)\n \n def dfs(self, steps, arrLen, pos):\n if pos < 0 or pos >= arrLen:\n return 0\n if steps == 0:\n return 1 if pos == 0 else 0\n return self.dfs(steps - 1, arrLen, pos - 1) + self.dfs(steps - 1, arrLen, pos) + self.dfs(steps - 1, arrLen, pos + 1)\n\n# APP2: DFS + Memoization. Memo:{(step, index), ways}\n# Time: O(steps * min(arrLen, steps + 1)), Space: O(steps * min(arrLen, steps + 1)) \n# Result: Accepted 50%\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n memo = {}\n return self.dfs(steps, arrLen, 0, memo)\n\n def dfs(self, steps, arrLen, pos, memo):\n if (steps, pos) in memo:\n return memo[(steps, pos)]\n if pos < 0 or pos > arrLen - 1:\n memo[(steps, pos)] = 0\n return 0\n if steps == 0:\n return 1 if pos == 0 else 0\n memo[(steps, pos)] = self.dfs(steps - 1, arrLen, pos - 1, memo) + self.dfs(steps - 1, arrLen, pos, memo) \\\n + self.dfs(steps - 1, arrLen, pos + 1, memo) \n return memo[(steps, pos)] % (10 ** 9 + 7)\n\n# APP3: DP. f[i][j]: total ways to get index j at ith step. ans = f[steps][0]. \n# f[i][j] = f[i - 1][j - 1] + f[i - 1][j] + f[i - 1][j + 1], f[0][0] = 1\n# Time: O(steps * arrLen) Space: O(steps * arrLen) \n# Result: TLE when 430, 148488\n\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n f = [[0] * arrLen for _ in range(steps + 1)]\n f[0][0] = 1\n for i in range(1, steps + 1):\n for j in range(arrLen):\n f[i][j] += f[i - 1][j]\n if j > 0:\n f[i][j] += f[i - 1][j - 1]\n if j < arrLen - 1:\n f[i][j] += f[i - 1][j + 1]\n return f[steps][0] % (10 ** 9 + 7)\n \n# APP4: DP. Optimize APP3. If steps = 3, even arrLen = 400, max we can reach index = steps + 1\n# So we can optimize arrLen = min(arrLen, steps + 1), just add one line to APP2\n# Time: O(steps * min(arrLen, steps + 1)), Space: O(steps * min(arrLen, steps + 1)) \n# Result: Runtime: 30% Memory: 100%\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n arrLen = min(arrLen, steps + 1)\n f = [[0] * arrLen for _ in range(steps + 1)]\n f[0][0] = 1\n for i in range(1, steps + 1):\n for j in range(arrLen):\n f[i][j] += f[i - 1][j]\n if j > 0:\n f[i][j] += f[i - 1][j - 1]\n if j < arrLen - 1:\n f[i][j] += f[i - 1][j + 1]\n return f[steps][0] % (10 ** 9 + 7)\n \n# APP5: DP. Optimize APP4 using rolling array because you only need to know the previous step status\n# But if you implemented like below, you\'re still allocating steps + 1 times new array\n# If it doesn\'t trigger the gc, space is still O(steps * min(arrLen, steps + 1)) \n# Time: O(steps * min(arrLen, steps + 1)) Space: O(steps * min(arrLen, steps + 1))\n# Result: Runtime: 50% Memory: 100%\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n arrLen = min(arrLen, steps + 1)\n prev = [1] + [0] * (arrLen - 1)\n for i in range(1, steps + 1): \n cur = [0] * arrLen\n for j in range(arrLen):\n cur[j] += prev[j]\n if j > 0:\n cur[j] += prev[j - 1]\n if j < arrLen - 1:\n cur[j] += prev[j + 1]\n prev = cur\n return prev[0] % (10 ** 9 + 7)\n \n# APP6: DP, Optimize APP5 impplementation. allocate two arrays memory only\n# Time: O(steps * min(arrLen, steps + 1)) Space: O(min(arrLen, steps + 1))\n# Result: Runtime: 48% Memory: 100%\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps is None or steps < 0 or not arrLen:\n return 0\n arrLen = min(arrLen, steps + 1)\n prev = [1] + [0] * (arrLen - 1)\n cur = [0] * arrLen\n for i in range(1, steps + 1): \n for j in range(arrLen):\n cur[j] = 0\n cur[j] += prev[j]\n if j > 0:\n cur[j] += prev[j - 1]\n if j < arrLen - 1:\n cur[j] += prev[j + 1]\n prev, cur = cur, prev\n return prev[0] % (10 ** 9 + 7)\n\t\t\n# APP7: DP, Optimize APP6 impplementation since you only need one array and one variable to track left\n def numWays(self, steps, arrLen):\n # write your code here\n arrLen = min(arrLen, steps + 1) \n f = [1]+[0]*(arrLen-1) # f[0] = 1\n \n for i in range(1, steps+1):\n old = 0 \n for j in range(arrLen):\n old_left = old\n old = f[j]\n if j > 0:\n f[j] += old_left \n if j < arrLen - 1:\n f[j] += f[j+1] \n return f[0] % (10 ** 9 + 7) | 34 | 0 | ['Dynamic Programming', 'Depth-First Search', 'Memoization', 'Python', 'Python3'] | 5 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅ Not so Hard ✅ Multiple Approaches Brute to Optimal ✅ Recursive + DP ✅ Fastest Beats 100% | not-so-hard-multiple-approaches-brute-to-ra7z | \n\n# YouTube Video Explanation\nhttps://youtu.be/BXVO1cwRbo8\n\n\uD83D\uDD25 Please like, share, and subscribe to support our channel\'s mission of making comp | millenium103 | NORMAL | 2023-10-15T04:08:45.834838+00:00 | 2023-10-15T05:43:55.303809+00:00 | 3,273 | false | \n\n# YouTube Video Explanation\n[https://youtu.be/BXVO1cwRbo8](https://youtu.be/BXVO1cwRbo8)\n\n\uD83D\uDD25 ***Please like, share, and subscribe to support our channel\'s mission of making complex concepts easy to understand.***\n\nSubscribe Link: https://www.youtube.com/@leetlogics/?sub_confirmation=1\n\n***Subscribe Goal: 100 Subscribers\nCurrent Subscribers: 68***\n\n# Intuition\nThe problem can be approached using dynamic programming. We want to find the number of ways to return to index 0 in an array of size `arrLen` after taking `steps` steps. The three approaches will solve this problem by considering various cases of stepping left, right, or staying in the same position.\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approaches\n## 1. Recursive Approach:(Time Limit Exceeded)\nIn the recursive approach, we calculate the number of ways to reach index 0 by making choices for each step. The base cases ensure that we don\'t go out of bounds and return 0 or 1 accordingly. We then sum the number of ways by taking different steps (left, right, or stay). This approach can be very inefficient for larger inputs.\n\n```\nclass Solution {\n private static final int MOD = 1000000007;\n public int numWays(int steps, int arrLen) {\n return countWays(steps, 0, arrLen);\n }\n private int countWays(int steps, int position, int arrLen) {\n if (position < 0 || position >= arrLen) {\n return 0;\n }\n if (steps == 0) {\n return position == 0 ? 1 : 0;\n }\n int ways = countWays(steps - 1, position, arrLen);\n ways = (ways + countWays(steps - 1, position - 1, arrLen)) % MOD;\n ways = (ways + countWays(steps - 1, position + 1, arrLen)) % MOD;\n return ways;\n }\n}\n```\n\n## 2. Top-Down Approach (Memoization):\nThe top-down approach improves efficiency by memoizing intermediate results. It uses a 2D array to store previously computed results to avoid redundant calculations. It calculates the number of ways to reach index 0 by considering steps left, right, or staying in the same position.\n```\nclass Solution {\n //memoized\n static final int MOD = 1_000_000_007;\n public int numWays(int steps, int arrLen) {\n arrLen = Math.min(steps / 2 + 1, arrLen);\n int[][] dp = new int[arrLen][steps + 1];\n for (int i = 0; i < dp.length; i++) Arrays.fill(dp[i], -1);\n return calculateWays(steps, 0, dp);\n }\n \n private static int calculateWays(int steps, int pos, int[][] dp) {\n if (steps < pos) return 0;\n if (steps == 0) return 1;\n if (dp[pos][steps] != -1) return dp[pos][steps];\n int ways = 0;\n if (pos < dp.length - 1) ways = (ways + calculateWays(steps - 1, pos + 1, dp)) % MOD;\n if (pos > 0) ways = (ways + calculateWays(steps - 1, pos - 1, dp)) % MOD;\n ways = (ways + calculateWays(steps - 1, pos, dp)) % MOD;\n dp[pos][steps] = ways;\n return ways;\n }\n}\n```\n\n\n## 3. Bottom-Up Approach:\nThe bottom-up approach uses a 2D array to store results from subproblems. It iterates through the steps and positions, calculating the number of ways to reach the current position by taking steps left, right, or staying. This approach reduces space complexity by using only two rows of the array.\n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n //bottom up\n int mod = 1000000007;\n int maxCol = Math.min(steps, arrLen - 1);\n // int[][] dp = new int[steps + 1][maxCol + 1];\n int[][] dp = new int[2][maxCol + 1];\n dp[0][0] = 1;\n\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxCol; j++) {\n // dp[i][j] = dp[i - 1][j];\n dp[i % 2][j] = dp[(i - 1) % 2][j];\n if (j - 1 >= 0) {\n //dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n dp[i % 2][j] = (dp[i % 2][j] + dp[(i - 1) % 2][j - 1]) % mod;\n }\n if (j + 1 <= maxCol) {\n // dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n dp[i % 2][j] = (dp[i % 2][j] + dp[(i - 1) % 2][j + 1]) % mod;\n }\n }\n }\n\n return dp[steps % 2][0];\n }\n}\n```\n\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n - Time Complexity for Approach 1: O(3^steps) - Exponential\n - Time Complexity for Approach 2: O(steps * arrLen) - Polynomial\n - Time Complexity for Approach 3: O(steps * arrLen) - Polynomial\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n - Space Complexity for Approach 2: O(steps * arrLen) - Polynomial\n - Space Complexity for Approach 3: O(min(steps, arrLen - 1)) - Linear\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code In Different Languages\n\n<iframe src="https://leetcode.com/playground/Yy48itkA/shared" frameBorder="0" width="600" height="500"></iframe>\n\n---\n\n\n | 32 | 1 | ['Dynamic Programming', 'Recursion', 'Memoization', 'Swift', 'Python', 'C++', 'Java', 'Go', 'JavaScript'] | 8 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Python] DP | python-dp-by-lee215-1ygi | Explantion\nAdd a dummy value of 0 to the beginning, easier to do sum\n\n\nPython:\npython\n def numWays(self, steps, n, mod=10 ** 9 + 7):\n A = [0, 1 | lee215 | NORMAL | 2019-11-24T17:03:32.260544+00:00 | 2019-12-05T16:33:43.794910+00:00 | 4,651 | false | ## **Explantion**\nAdd a dummy value of `0` to the beginning, easier to do `sum`\n<br>\n\n**Python:**\n```python\n def numWays(self, steps, n, mod=10 ** 9 + 7):\n A = [0, 1]\n for t in xrange(steps):\n A[1:] = [sum(A[i - 1:i + 2]) % mod for i in xrange(1, min(n + 1, t + 3))]\n return A[1] % mod\n``` | 30 | 8 | [] | 8 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Dynamic Programming Staircase || Beginner Friendly || Easy To Understand || Python || Beats 100 % || | dynamic-programming-staircase-beginner-f-wfhr | BEATS 100%\n\n\n# Intuition\n\n\nImagine you are standing at the beginning of a long staircase. You want to reach the top, but you can only take one or two step | vaish_1929 | NORMAL | 2023-10-15T04:27:40.001923+00:00 | 2023-10-15T04:49:08.210728+00:00 | 3,972 | false | # BEATS 100%\n\n\n# Intuition\n\n\nImagine you are standing at the beginning of a long staircase. You want to reach the top, but you can only take one or two steps at a time. How many different ways can you reach the top?\n\nThe number of ways to reach the top of the staircase depends on the number of ways to reach the previous step and the next step. This can be modeled using a dynamic programming recurrence relation.\n\n# Approach\n\nThe following algorithm is used to calculate the number of ways to reach the top of the staircase:\n\n1. **Define a modulo constant** to prevent integer overflow.\n2. **Calculate the maximum possible position** on the staircase that can be reached.\n3. **Initialize an array** to store the number of ways to reach each position on the staircase.\n4. **Set the base case:** There is one way to stay at the initial position.\n5. **Iterate through the number of steps taken:**\n * Set a variable `left` to 0.\n * Iterate through possible positions on the staircase, considering bounds:\n * Calculate the number of ways to reach the current position `j` using the dynamic programming recurrence relation and considering the `left` value.\n * Update `left` and `ways[j]`.\n6. **Return the value of `ways[0]`,** which represents the number of ways to reach the top of the staircase.\n\n# Complexity\n\n* **Time complexity:** $O(n)$\n* **Space complexity:** $O(n)$\n\nwhere $n$ is the number of steps taken.\n\n# Code\n\n```python\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n # Define a modulo constant to prevent integer overflow\n modulo = 1000000007\n\n # Calculate the maximum possible position on the staircase that can be reached\n max_len = min(arrLen, 1 + steps // 2)\n\n # Initialize an array to store the number of ways to reach each position on the staircase\n ways = [0] * (max_len + 1)\n\n # Set the base case: There is one way to stay at the initial position\n ways[0] = 1\n\n # Iterate through the number of steps taken\n for i in range(steps):\n left = 0\n\n # Iterate through possible positions on the staircase, considering bounds\n for j in range(min(max_len, i + 2, steps - i + 3)):\n # Calculate the number of ways to reach the current position `j`\n # using the dynamic programming recurrence relation and considering the `left` value\n left, ways[j] = ways[j], (ways[j] + left + ways[j + 1]) % modulo\n\n # The `ways[0]` value represents the number of ways to reach the top of the staircase\n return ways[0]\n```\n# RUBY\n```\ndef num_ways(steps, max_position)\n @max = max_position - 1\n @memo = Array.new(max_position) { {} }\n ways(0, steps) % 1000000007\nend\n\ndef ways(current_position, remaining_steps)\n return (current_position == 0 ? 1 : 0) if remaining_steps == 0\n return @memo[current_position][remaining_steps] if @memo[current_position][remaining_steps]\n\n total = ways(current_position, remaining_steps - 1)\n total += ways(current_position - 1, remaining_steps - 1) unless current_position == 0\n total += ways(current_position + 1, remaining_steps - 1) unless current_position == @max\n\n @memo[current_position][remaining_steps] = total\nend\n\n```\n\n# C++\n```\nconst int MOD = 1e9 + 7;\n\nconst int maxPositions = 250 + 3;\nconst int maxSteps = 500 + 3;\n\nclass Solution {\npublic:\n int dp[maxSteps][maxPositions];\n\n int calculateWays(int currentPosition, int remainingSteps, int maxPosition) {\n if (remainingSteps == 0)\n return dp[remainingSteps][currentPosition] = (currentPosition == 0) ? 1 : 0;\n\n if (dp[remainingSteps][currentPosition] != -1)\n return dp[remainingSteps][currentPosition];\n\n int ways = 0;\n for (int dir = -1; dir <= 1; dir++) {\n int nextPosition = currentPosition + dir;\n\n if (nextPosition >= remainingSteps)\n continue;\n\n if (nextPosition >= 0 && nextPosition < maxPosition) {\n ways += calculateWays(nextPosition, remainingSteps - 1, maxPosition);\n ways %= MOD;\n }\n }\n\n return dp[remainingSteps][currentPosition] = ways;\n }\n\n int numWays(int steps, int maxPosition) {\n memset(dp, -1, sizeof(dp));\n return calculateWays(0, steps, maxPosition);\n }\n};\n\n```\n# Java\n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n if (arrLen == 1) {\n return 1;\n }\n \n arrLen = Math.min(steps / 2 + 1, arrLen);\n long modulo = 1_000_000_007;\n\n long[] current = new long[arrLen];\n current[0] = 1;\n current[1] = 1;\n long[] next = new long[arrLen];\n\n for (int i = 2; i <= steps; i++) {\n int maxPos = Math.min(i + 1, arrLen);\n next[0] = (current[0] + current[1]) % modulo;\n for (int j = 1; j < maxPos - 1; j++) {\n next[j] = (current[j - 1] + current[j] + current[j + 1]) % modulo;\n }\n next[maxPos - 1] = (current[maxPos - 2] + current[maxPos - 1]) % modulo;\n\n long[] temp = current;\n current = next;\n next = temp;\n }\n\n return (int) current[0];\n }\n}\n\n```\n\n# JavaScript\n```\nvar numWays = function(numSteps, arrayLength) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n const mod = 1000000007;\n\n // Calculate the maximum position the pointer can reach, which is the minimum of numSteps/2 and arrayLength - 1.\n const maxPosition = Math.min(Math.floor(numSteps / 2), arrayLength - 1);\n\n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n const dp = new Array(numSteps + 1).fill().map(() => new Array(maxPosition + 1).fill(0));\n\n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1;\n\n // Loop through the number of steps.\n for (let i = 1; i <= numSteps; i++) {\n for (let j = 0; j <= maxPosition; j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j];\n\n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n\n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n\n // The final result is stored in dp[numSteps][0], representing the number of ways to reach the initial position after taking \'numSteps\' steps.\n return dp[numSteps][0];\n};\n\n\n```\n# PHP\n```\nclass Solution {\n function numWays($numSteps, $arrayLength) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n $mod = 1000000007;\n \n // Calculate the maximum position the pointer can reach, which is the minimum of numSteps/2 and arrayLength - 1.\n $maxPosition = min($numSteps / 2, $arrayLength - 1);\n \n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n $dp = array_fill(0, $numSteps + 1, array_fill(0, $maxPosition + 1, 0));\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n $dp[0][0] = 1;\n \n // Loop through the number of steps.\n for ($i = 1; $i <= $numSteps; $i++) {\n for ($j = 0; $j <= $maxPosition; $j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n $dp[$i][$j] = $dp[$i - 1][$j];\n \n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if ($j > 0) {\n $dp[$i][$j] = ($dp[$i][$j] + $dp[$i - 1][$j - 1]) % $mod;\n }\n \n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if ($j < $maxPosition) {\n $dp[$i][$j] = ($dp[$i][$j] + $dp[$i - 1][$j + 1]) % $mod;\n }\n }\n }\n \n // The final result is stored in dp[numSteps][0], representing the number of ways to reach the initial position after taking \'numSteps\' steps.\n return $dp[$numSteps][0];\n }\n}\n\n``` | 29 | 0 | ['Dynamic Programming', 'PHP', 'Python', 'C++', 'Java', 'Python3', 'Ruby', 'JavaScript'] | 5 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 🔥Brute Force to Efficient Method🤩 | Java | C++ | Python | JavaScript | C# | PHP | brute-force-to-efficient-method-java-c-p-7cps | 1st Method :- Brute force\n\nHere\'s a step-by-step breakdown of how the code works:\n\n1. Define a modulus value (mod) to handle the modulo operation to avoid | Akhilesh21 | NORMAL | 2023-10-15T01:19:18.973566+00:00 | 2023-10-15T01:19:18.973589+00:00 | 2,722 | false | # 1st Method :- Brute force\n\nHere\'s a step-by-step breakdown of how the code works:\n\n1. Define a modulus value (`mod`) to handle the modulo operation to avoid integer overflow. It\'s set to 1000000007, which is commonly used in competitive programming.\n\n2. Calculate `maxPosition`, which represents the maximum position the pointer can reach. This value is the minimum of half the number of steps (`steps / 2`) and `arrLen - 1`.\n\n3. Create a 2D array `dp` to store the number of ways to reach each position at each step. It has dimensions `[steps + 1][maxPosition + 1]`.\n\n4. Initialize `dp[0][0]` to 1, as there is one way to stay at position 0 after 0 steps.\n\n5. Loop through each step `i` from 1 to `steps`.\n\n6. For each step `i`, loop through each possible position `j` from 0 to `maxPosition`.\n\n7. For each position, initialize `dp[i][j]` with the number of ways to stay at the same position as the previous step, which is `dp[i - 1][j]`.\n\n8. If the current position `j` is greater than 0, add the number of ways to reach it by moving left (subtracting 1 from `j`).\n\n9. If the current position `j` is less than the maximum position, add the number of ways to reach it by moving right (adding 1 to `j`).\n\n10. Take the modulo `mod` for each update to prevent integer overflow.\n\n11. Finally, the result is stored in `dp[steps][0]`, which represents the number of ways to reach the initial position (position 0) after taking the specified number of steps.\n## Code\n``` Java []\nclass Solution {\n public int numWays(int steps, int arrLen) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n int mod = 1000000007;\n \n // Calculate the maximum position the pointer can reach, which is the minimum of steps/2 and arrLen - 1.\n int maxPosition = Math.min(steps / 2, arrLen - 1);\n \n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n int[][] dp = new int[steps + 1][maxPosition + 1];\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1;\n \n // Loop through the number of steps.\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxPosition; j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j];\n \n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n \n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n \n // The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return dp[steps][0];\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n const int mod = 1000000007;\n \n int maxPosition = std::min(steps / 2, arrLen - 1);\n \n // Create a 2D vector dp to store the number of ways to reach a specific position at each step.\n vector<vector<int>> dp(steps + 1, vector<int>(maxPosition + 1, 0));\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1;\n \n // Loop through the number of steps.\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxPosition; j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j];\n \n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n \n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n \n // The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return dp[steps][0];\n }\n};\n```\n``` Python []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n # Define a modulus value for taking the modulo operation to avoid overflow.\n mod = 1000000007\n \n # Calculate the maximum position the pointer can reach, which is the minimum of steps/2 and arrLen - 1.\n maxPosition = min(steps // 2, arrLen - 1)\n \n # Create a 2D array dp to store the number of ways to reach a specific position at each step.\n dp = [[0] * (maxPosition + 1) for _ in range(steps + 1)]\n \n # Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1\n \n # Loop through the number of steps.\n for i in range(1, steps + 1):\n for j in range(maxPosition + 1):\n # Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j]\n \n # If the current position is greater than 0, add the number of ways to reach it by moving left.\n if j > 0:\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod\n \n # If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if j < maxPosition:\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod\n \n # The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return dp[steps][0]\n\n```\n``` JavaScript []\nvar numWays = function(steps, arrLen) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n const mod = 1000000007;\n\n // Calculate the maximum position the pointer can reach, which is the minimum of steps/2 and arrLen - 1.\n const maxPosition = Math.min(Math.floor(steps / 2), arrLen - 1);\n\n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n const dp = new Array(steps + 1).fill().map(() => new Array(maxPosition + 1).fill(0));\n\n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1;\n\n // Loop through the number of steps.\n for (let i = 1; i <= steps; i++) {\n for (let j = 0; j <= maxPosition; j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j];\n\n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n\n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n\n // The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return dp[steps][0];\n};\n\n```\n``` C# []\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n int mod = 1000000007;\n \n // Calculate the maximum position the pointer can reach, which is the minimum of steps/2 and arrLen - 1.\n int maxPosition = Math.Min(steps / 2, arrLen - 1);\n \n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n int[][] dp = new int[steps + 1][];\n for (int i = 0; i <= steps; i++) {\n dp[i] = new int[maxPosition + 1];\n }\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0][0] = 1;\n \n // Loop through the number of steps.\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxPosition; j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n dp[i][j] = dp[i - 1][j];\n \n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n \n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n \n // The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return dp[steps][0];\n }\n}\n```\n``` PHP []\nclass Solution {\n function numWays($steps, $arrLen) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n $mod = 1000000007;\n \n // Calculate the maximum position the pointer can reach, which is the minimum of steps/2 and arrLen - 1.\n $maxPosition = min($steps / 2, $arrLen - 1);\n \n // Create a 2D array dp to store the number of ways to reach a specific position at each step.\n $dp = array_fill(0, $steps + 1, array_fill(0, $maxPosition + 1, 0));\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n $dp[0][0] = 1;\n \n // Loop through the number of steps.\n for ($i = 1; $i <= $steps; $i++) {\n for ($j = 0; $j <= $maxPosition; $j++) {\n // Initialize the number of ways to stay at the current position with the number of ways to stay at the same position in the previous step.\n $dp[$i][$j] = $dp[$i - 1][$j];\n \n // If the current position is greater than 0, add the number of ways to reach it by moving left.\n if ($j > 0) {\n $dp[$i][$j] = ($dp[$i][$j] + $dp[$i - 1][$j - 1]) % $mod;\n }\n \n // If the current position is less than the maximum position, add the number of ways to reach it by moving right.\n if ($j < $maxPosition) {\n $dp[$i][$j] = ($dp[$i][$j] + $dp[$i - 1][$j + 1]) % $mod;\n }\n }\n }\n \n // The final result is stored in dp[steps][0], representing the number of ways to reach the initial position after taking \'steps\' steps.\n return $dp[$steps][0];\n }\n}\n\n```\n\n# Complexity\n#### Time complexity: O(steps^2)\nThe time complexity of the solution can be analyzed as follows:\n\n1. The outer loop runs from 1 to `steps`, which means it iterates through each step, so it contributes O(steps) to the time complexity.\n\n2. The inner loop runs from 0 to `maxPosition`, where `maxPosition` is the minimum of `steps/2` and `arrLen - 1`. In the worst case, this inner loop iterates `steps/2` times. So, the inner loop contributes O(steps) to the time complexity.\n\n3. Inside the inner loop, there are constant time operations such as addition, subtraction, and modulo operations. These operations do not depend on the input size and can be considered O(1).\n\nCombining all these factors, the overall time complexity of the solution is O(steps * maxPosition) in the worst case, where `maxPosition` is O(steps/2), so it simplifies to O(steps^2).\n\n#### Space complexity: O(steps^2)\nThe space complexity is determined by the extra space used by the `dp` array.\n\n1. The `dp` array is a 2D array with dimensions `[steps + 1][maxPosition + 1]`. So, it consumes space proportional to the product of `steps` and `maxPosition`.\n\n2. `maxPosition` is defined as the minimum of `steps/2` and `arrLen - 1`, which ensures it is bounded and does not exceed `steps/2`. \n\nCombining these factors, the space complexity is O(steps * maxPosition), which simplifies to O(steps^2) in the worst case, as it depends on the number of steps.\n\nThis solution has a polynomial time and space complexity, which can handle reasonably large inputs, but may not be the most efficient for very large values of `steps`. Nevertheless, it provides an efficient way to solve the problem without running into time and space constraints for typical inputs.\n\n\n\n\n# 2nd Method :- Efficient Method\n\nHere\'s a step-by-step breakdown of how the code works:\n\n1. Define a modulus value (`kMod`) to handle the modulo operation and prevent integer overflow. It\'s set to 1,000,000,007, which is commonly used in competitive programming.\n\n2. Calculate `n`, which represents the number of positions to consider. It is the minimum of `arrLen` and `steps/2 + 1`. This ensures that we only consider positions that are within a reasonable range.\n\n3. Create an array `dp` to store the number of ways to stay at each position. It\'s initialized with all zeros, except `dp[0]`, which is set to 1 as there is one way to stay at position 0 after 0 steps.\n\n4. Use a `while` loop to iterate through each step. The loop decrements the `steps` variable in each iteration.\n\n5. In each step, create a new array `newDp` to store updated values for each position. This array will be used to compute the number of ways to stay at each position after the current step.\n\n6. Use a `for` loop to iterate through each position `i` from 0 to `n`.\n\n7. For each position, initialize `newDp[i]` with the value from the previous step, which represents the number of ways to stay at the same position.\n\n8. Check if it\'s possible to move left (i - 1 >= 0), and if so, add the number of ways to reach the current position by moving left.\n\n9. Check if it\'s possible to move right (i + 1 < n), and if so, add the number of ways to reach the current position by moving right.\n\n10. Take the modulo operation with `kMod` for each `newDp[i]` to avoid integer overflow.\n\n11. Update the `dp` array with the `newDp` array for the next step.\n\n12. After completing all steps, the final result is stored in `dp[0]`, which represents the number of ways to reach the initial position (position 0) after taking the specified number of steps.\n\n## Code\n``` Java []\nclass Solution {\n public int numWays(int steps, int arrLen) {\n final int kMod = 1_000_000_007; // Define a modulus value to avoid integer overflow.\n final int n = Math.min(arrLen, steps / 2 + 1); // Calculate the number of positions we need to consider.\n // dp[i] := # of ways to stay on index i\n long[] dp = new long[n]; // Create an array to store the number of ways to stay at each position.\n dp[0] = 1; // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n\n while (steps-- > 0) { // Loop through each step.\n long[] newDp = new long[n]; // Create a new array to store updated values for each position.\n for (int i = 0; i < n; ++i) { // Iterate through each position.\n newDp[i] = dp[i]; // Initialize with the number of ways to stay at the same position in the previous step.\n if (i - 1 >= 0)\n newDp[i] += dp[i - 1]; // Add the number of ways to reach the current position by moving left.\n if (i + 1 < n)\n newDp[i] += dp[i + 1]; // Add the number of ways to reach the current position by moving right.\n newDp[i] %= kMod; // Take the modulo to avoid integer overflow.\n }\n dp = newDp; // Update dp with the newDp array for the next step.\n }\n\n return (int) dp[0]; // The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n const int kMod = 1\'000\'000\'007; // Define a modulus value to avoid integer overflow.\n const int n = std::min(arrLen, steps / 2 + 1); // Calculate the number of positions we need to consider.\n // dp[i] := # of ways to stay on index i\n vector<long> dp(n); // Create an array to store the number of ways to stay at each position.\n dp[0] = 1; // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n\n while (steps-- > 0) { // Loop through each step.\n vector<long> newDp(n); // Create a new array to store updated values for each position.\n for (int i = 0; i < n; ++i) { // Iterate through each position.\n newDp[i] = dp[i]; // Initialize with the number of ways to stay at the same position in the previous step.\n if (i - 1 >= 0)\n newDp[i] += dp[i - 1]; // Add the number of ways to reach the current position by moving left.\n if (i + 1 < n)\n newDp[i] += dp[i + 1]; // Add the number of ways to reach the current position by moving right.\n newDp[i] %= kMod; // Take the modulo to avoid integer overflow.\n }\n dp = newDp; // Update dp with the newDp array for the next step.\n }\n\n return static_cast<int>(dp[0]); // The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n }\n};\n```\n``` Python []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n # Define a modulus value for taking the modulo operation to avoid integer overflow.\n kMod = 1000000007\n \n # Calculate the number of positions we need to consider, which is the minimum of arrLen and steps // 2 + 1.\n n = min(arrLen, steps // 2 + 1)\n \n # Create an array dp to store the number of ways to stay at each position.\n dp = [0] * n\n \n # Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0] = 1\n\n # Loop through each step.\n while steps > 0:\n # Create a new array newDp to store updated values for each position.\n newDp = [0] * n\n \n # Iterate through each position.\n for i in range(n):\n # Initialize with the number of ways to stay at the same position in the previous step.\n newDp[i] = dp[i]\n \n # Add the number of ways to reach the current position by moving left if it\'s a valid move.\n if i - 1 >= 0:\n newDp[i] += dp[i - 1]\n \n # Add the number of ways to reach the current position by moving right if it\'s a valid move.\n if i + 1 < n:\n newDp[i] += dp[i + 1]\n \n # Take the modulo to avoid integer overflow.\n newDp[i] %= kMod\n\n # Update dp with the newDp array for the next step.\n dp = newDp\n \n # Decrement the number of steps.\n steps -= 1\n\n # The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n return dp[0]\n```\n``` JavaScript []\nvar numWays = function(steps, arrLen) {\n // Define a modulus value for taking the modulo operation to avoid overflow.\n const kMod = 1000000007;\n \n // Calculate the number of positions we need to consider, which is the minimum of arrLen and steps/2 + 1.\n const n = Math.min(arrLen, Math.floor(steps / 2) + 1);\n \n // Create an array dp to store the number of ways to stay at each position.\n const dp = new Array(n).fill(0);\n \n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0] = 1;\n\n // Loop through each step.\n while (steps > 0) {\n // Create a new array newDp to store updated values for each position.\n const newDp = new Array(n).fill(0);\n \n // Iterate through each position.\n for (let i = 0; i < n; i++) {\n // Initialize with the number of ways to stay at the same position in the previous step.\n newDp[i] = dp[i];\n \n // Add the number of ways to reach the current position by moving left if it\'s a valid move.\n if (i - 1 >= 0) {\n newDp[i] += dp[i - 1];\n }\n \n // Add the number of ways to reach the current position by moving right if it\'s a valid move.\n if (i + 1 < n) {\n newDp[i] += dp[i + 1];\n }\n \n // Take the modulo to avoid integer overflow.\n newDp[i] %= kMod;\n }\n\n // Update dp with the newDp array for the next step.\n dp.splice(0, n, ...newDp);\n\n // Decrement the number of steps.\n steps--;\n }\n\n // The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n return dp[0];\n};\n```\n``` C# []\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n // Define a modulus value for taking the modulo operation to avoid integer overflow.\n const int kMod = 1_000_000_007;\n\n // Calculate the number of positions we need to consider, which is the minimum of arrLen and steps / 2 + 1.\n int n = Math.Min(arrLen, steps / 2 + 1);\n\n // Create an array dp to store the number of ways to stay at each position.\n long[] dp = new long[n];\n\n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n dp[0] = 1;\n\n // Loop through each step.\n while (steps-- > 0) {\n // Create a new array newDp to store updated values for each position.\n long[] newDp = new long[n];\n\n // Iterate through each position.\n for (int i = 0; i < n; ++i) {\n // Initialize with the number of ways to stay at the same position in the previous step.\n newDp[i] = dp[i];\n\n // Add the number of ways to reach the current position by moving left if it\'s a valid move.\n if (i - 1 >= 0) {\n newDp[i] += dp[i - 1];\n }\n\n // Add the number of ways to reach the current position by moving right if it\'s a valid move.\n if (i + 1 < n) {\n newDp[i] += dp[i + 1];\n }\n\n // Take the modulo to avoid integer overflow.\n newDp[i] %= kMod;\n }\n\n // Update dp with the newDp array for the next step.\n dp = newDp;\n }\n\n // The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n return (int)dp[0];\n }\n}\n\n```\n``` PHP []\nclass Solution {\n function numWays($steps, $arrLen) {\n // Define a modulus value for taking the modulo operation to avoid integer overflow.\n $kMod = 1000000007;\n\n // Calculate the number of positions we need to consider, which is the minimum of arrLen and steps / 2 + 1.\n $n = min($arrLen, intval($steps / 2) + 1);\n\n // Create an array dp to store the number of ways to stay at each position.\n $dp = array_fill(0, $n, 0);\n\n // Initialize the number of ways to stay at position 0 after 0 steps to 1.\n $dp[0] = 1;\n\n // Loop through each step.\n while ($steps > 0) {\n // Create a new array newDp to store updated values for each position.\n $newDp = array_fill(0, $n, 0);\n\n // Iterate through each position.\n for ($i = 0; $i < $n; ++$i) {\n // Initialize with the number of ways to stay at the same position in the previous step.\n $newDp[$i] = $dp[$i];\n\n // Add the number of ways to reach the current position by moving left if it\'s a valid move.\n if ($i - 1 >= 0) {\n $newDp[$i] += $dp[$i - 1];\n }\n\n // Add the number of ways to reach the current position by moving right if it\'s a valid move.\n if ($i + 1 < $n) {\n $newDp[$i] += $dp[$i + 1];\n }\n\n // Take the modulo to avoid integer overflow.\n $newDp[$i] %= $kMod;\n }\n\n // Update dp with the newDp array for the next step.\n $dp = $newDp;\n\n // Decrement the number of steps.\n $steps--;\n }\n\n // The final result is stored in dp[0], representing the number of ways to reach the initial position after taking the specified number of steps.\n return (int)$dp[0];\n }\n}\n\n```\n\n## Complexity\n#### Time complexity: O(steps^2)\nThe time complexity of the solution can be analyzed as follows:\n\n1. The outer loop iterates while `steps` is greater than 0. Since we decrement `steps` by 1 in each iteration, the loop runs for `steps` iterations.\n\n2. Within the outer loop, there is an inner loop that iterates from 0 to `n`, where `n` is the minimum of `arrLen` and `steps/2 + 1`. In the worst case, this inner loop runs `n` times.\n\n3. Inside the inner loop, there are constant time operations such as addition, subtraction, and modulo operations. These operations do not depend on the input size and can be considered O(1).\n\nCombining all these factors, the overall time complexity of the solution is O(steps * n) in the worst case, where `n` is O(steps/2). So, it simplifies to O(steps^2).\n\n#### Space complexity: O(steps)\nThe space complexity is determined by the extra space used by the arrays.\n\n1. The `dp` array has a size of `n`. In the worst case, `n` is O(steps/2), so the space complexity for `dp` is O(steps).\n\n2. The `newDp` array also has a size of `n`, contributing O(steps) to space complexity.\n\n3. There are other constant space variables such as `kMod`, `n`, and loop control variables, which can be considered O(1).\n\nCombining these factors, the space complexity is O(steps) in the worst case, as it depends on the number of steps.\n\n\n# Up Vote Guys | 26 | 3 | ['Dynamic Programming', 'PHP', 'Python', 'C++', 'Java', 'Python3', 'JavaScript', 'C#'] | 7 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python Cache DP | python-cache-dp-by-doudouzi-vqpw | self explanatory solution using dynamic programming\n\n1. dp(pos, step) = sum(dp(pos+1, step-1), dp(pos-1, step-1), dp(pos, step-1))\n2. return 0 when either ou | doudouzi | NORMAL | 2019-11-24T04:09:28.727981+00:00 | 2019-11-24T04:09:28.728022+00:00 | 2,563 | false | self explanatory solution using dynamic programming\n\n1. dp(pos, step) = sum(dp(pos+1, step-1), dp(pos-1, step-1), dp(pos, step-1))\n2. return 0 when either out of range or pos > steps (impossible back to origin)\n3. return 1 when steps == pos\n\n```\nfrom functools import lru_cache\n\nclass Solution:\n def numWays(self, steps: int, n: int) -> int:\n \n MOD = 10**9 + 7\n \n @lru_cache(None)\n def calculate(pos, steps):\n if pos < 0 or pos >= n: return 0\n if pos > steps: return 0\n if steps == pos: return 1\n steps -= 1\n return (calculate(pos+1, steps) + calculate(pos-1, steps) + calculate(pos, steps)) % MOD\n \n return calculate(0, steps)\n``` | 23 | 1 | [] | 9 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Java] Iterative DP solution O(n) space | java-iterative-dp-solution-on-space-by-m-olib | ```\nclass Solution {\n \n static int mod = (int)Math.pow(10, 9) + 7;\n \n public int numWays(int steps, int n) {\n \n int[] arr = new | manrajsingh007 | NORMAL | 2019-11-24T04:01:23.926306+00:00 | 2019-11-27T08:47:16.346484+00:00 | 2,569 | false | ```\nclass Solution {\n \n static int mod = (int)Math.pow(10, 9) + 7;\n \n public int numWays(int steps, int n) {\n \n int[] arr = new int[n];\n if(n <= 1) return n;\n arr[0] = 1;\n arr[1] = 1;\n \n for(int j = 1; j < steps; j++){\n \n int[] temp = new int[n]; \n \n for(int i = 0; i <= Math.min(n - 1, steps - j); i++){\n long ans = arr[i];\n if(i > 0) ans = (ans + arr[i - 1]) % mod;\n if(i < n - 1) ans = (ans + arr[i + 1]) % mod;\n temp[i] = (int)ans;\n }\n \n arr = temp;\n }\n \n return arr[0];\n \n }\n} | 14 | 2 | ['Dynamic Programming'] | 5 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 2ms Beats 99.57%||C++ recursive DP->iterative DP with optimized SC||with Note on Motzkin numbers | 2ms-beats-9957c-recursive-dp-iterative-d-dkem | Intuition\n Describe your first thoughts on how to solve this problem. \n1st approach uses recursion with memo.\n2nd approach uses iterative DP with optimized s | anwendeng | NORMAL | 2023-10-15T02:06:18.127653+00:00 | 2023-10-15T07:01:13.656629+00:00 | 1,550 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n1st approach uses recursion with memo.\n2nd approach uses iterative DP with optimized space. The same trick for the space optimization is to use bitwise-and `i&1` to obtain `i%2` like solving the question [Leetcode 2742. Painting the Walls](https://leetcode.com/problems/painting-the-walls/solutions/4166124/beats-9953cpython-recursive-2d-dp-iterative-dp-with-optimized-sc/)\n# A Note on Motzkin number\nMotzkin number for n is the number of non-negative integer sequences of length n+1 in which the opening and ending elements are 0, and the difference between any two consecutive elements is \u22121, 0 or 1. \n\nThere is a 3-term recurrence\nM(n) = (2n+1) * M(n-1)) / (n+2) + (3n-3) * M(n-2) / (n+2)\n\nThis question has a similar pattern for Motzkin numbers.\nhttps://en.wikipedia.org/wiki/Motzkin_number\n# Approach\n<!-- Describe your approach to solving the problem. -->\nThis C++ code is intended to calculate the number of ways to reach position 0 in an array after taking a certain number of steps. It uses dynamic programming to solve the problem efficiently.\n\n1. The numWays function calculates the number of ways to reach position 0 in an array after taking a certain number of steps. It also takes an `arrLen` parameter, which represents the maximum position that can be reached in the array.\n\n2. The code uses a 2D vector called `dp` with two rows (2 rows for optimizing space) and a maximum of `n+1` columns. This vector is used to store the dynamic programming values.\n\n3. The base case is initialized with `dp[0][0] = 1`, indicating that there is one way to start at position 0.\n\n4. The code then uses a double loop to iterate over the number of steps and the positions in the array. It calculates the number of ways to reach the current position based on the number of ways to reach the previous positions.\n\n5. The `#pragma unroll` directive is used to potentially optimize the loop. It\'s not standard C++ and depends on the compiler being used.\n\n6. The result is stored in the `dp` array for each step, and it finally returns the number of ways to reach position 0 after \'steps\' steps.\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n$ O(steps * n)$\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$ O(steps * n) \\to O(n)$\n# Code\n```\nclass Solution {\npublic:\n const int mod=1e9+7;\n vector<vector<int>> dp;\n int f(int steps, int i, int n) {//(remaining moves, index, n)\n if (steps==0) \n return (i==0) ? 1 : 0;\n\n if (dp[steps][i]!= -1) \n return dp[steps][i];\n\n long long ans=f(steps-1, i, n) %mod;//stay\n\n // Move to the right \n if (i<n-1) \n ans= (ans+f(steps-1, i+1, n))%mod;\n\n // Move to the left \n if (i>0) \n ans = (ans+f(steps-1, i-1, n))%mod;\n \n return dp[steps][i]=ans;\n }\n\n int numWays(int steps, int arrLen) {\n int n=min(steps/2+1, arrLen);//maximial position can reached\n dp.assign(steps+1, vector<int>(n+1, -1));\n return f(steps, 0, n);\n }\n};\n```\n# iterative DP with optimized SC\n```\nclass Solution {\npublic:\n const int mod=1e9+7;\n\n int numWays(int steps, int arrLen) {\n int n=min(steps/2+1, arrLen);//maximial reachable position \n //Create a 2D vector dp to store the dynamic programming values\n //(remaining moves, index)\n vector<vector<int>> dp(2, vector<int>(n+1, 0));\n dp[0][0]=1;//Set the base case 1 way to start at position 0\n #pragma unroll\n for(int mv=1; mv<=steps; mv++){\n for(int i=0; i<=n; i++){\n //Compute the number of ways to reach the current position\n long long ans = dp[(mv-1)&1][i];\n if (i <n-1) ans = (ans+dp[(mv-1)&1][i+1]) % mod;\n if (i>0) ans = (ans+dp[(mv-1)&1][i-1]) % mod;\n dp[mv&1][i] = ans;\n }\n }\n return dp[steps&1][0];\n }\n};\n```\n# How to optimizely speed up? Just replace `vector<vector<int>> dp(2, vector<int>(n+1, 0));` by the following native array! Runtime 2ms & beats 99.57%\n```\n//(remaining moves, index)\nint dp[2][252]={0};\n```\n | 13 | 0 | ['Dynamic Programming', 'C++'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | DP = Drone Pilot algorithm = DFS + memo + Drone flying nightmare | dp-drone-pilot-algorithm-dfs-memo-drone-suluq | Okay, I admit that I am too jokey about my tittle. But I want you to get the same lesson that I get from my drone flying. \n\nIntuition:\nHave you every flied a | codedayday | NORMAL | 2020-05-09T07:29:55.524164+00:00 | 2020-05-12T14:09:26.616047+00:00 | 1,445 | false | Okay, I admit that I am too jokey about my tittle. But I want you to get the same lesson that I get from my drone flying. \n\n**Intuition:**\nHave you every flied a drone along a straigt line? This can help you quickly understand the largest index you can visit is no greater than steps/2. Otherwise, you may lose your drone. \n\nAnother intition:\nat each index/position, all your choice are: \n```\nmove left,\nstay\nmove right\n```\nThey can be encoded into: \n-1\n+0\n+1\nThis can make your code more compact.\n\n**Complexity**\nSpace: O(steps * min(steps/2, arrLen))\nTime: O(steps * min(steps/2, arrLen))\n\n\n```\nclass Solution { // Top-down dp: dfs + memoization\npublic://Time/Space: O(steps * min(steps/2, arrLen)), O(steps * min(steps/2, arrLen))\n int numWays(int steps, int arrLen) {\n _maxPosition = min(arrLen-1, steps/2); // A joke: I have a DJI drone, claims it can fly 30min, guess what is maximum distance I dare to let fly? 15min away right?\n // _memo[i][j]: # of ways for your pointer are in position j after i steps move\n _memo = vector<vector<int> > (steps+1, vector<int>(_maxPosition+1, -1));\n //_memo = vector<vector<int> > (steps+1, vector<int>(_maxPosition+1, 0)); // init value 0 is not good, can not differentiate from invalid path/scheme. \n return dfs(steps, 0);\n }\n \nprivate: \n vector<vector<int> > _memo;\n int _maxPosition;\n const int kMod = 1e9 + 7;\n\t\n\t//returned value: # of ways for your pointer are in index \'position\' after \'steps\' move\n int dfs(int steps, int position) { // dfs + memo \n if(position <0 || position > _maxPosition || position > steps ) return 0; // out-of-range or out-of-chance to go home \n if(steps == 0) return _memo[steps][position] = (position == 0); \n if(steps == position) return _memo[steps][position] = 1; // to safely return home, go home now and accmulate 1 count\n if(_memo[steps][position]!=-1) return _memo[steps][position];\n \n long ans = 0;\n for(int i = -1; i <=1; i++) // -1, 0, 1 means: move Left, stay, move right\n ans = (ans + dfs(steps - 1, position + i) ) % kMod;\n return _memo[steps][position] = ans % kMod;\n }\n};\n```\n\n**P.S.:**\nIf you like the joke about Drone, please help upvote. Thanks.\n\n\n | 12 | 2 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java Recursive (Memoization) | java-recursive-memoization-by-himsngh-6pco | At every inndex we reach we have 3 possible options either to stay, or to move to the right, or to the left. We travel all the possible position and check whe | himsngh | NORMAL | 2020-08-11T10:46:46.398821+00:00 | 2020-08-22T09:16:51.058677+00:00 | 1,237 | false | At every inndex we reach we have 3 possible options either to stay, or to move to the right, or to the left. We travel all the possible position and check whether we can reach the index 0 or not and save the solution for that particular index in the map. So that when we enncounter it again we have the solution for that position with required number of steps.\n```\nclass Solution {\n \n HashMap<String,Long> map = new HashMap();\n \n public int numWays(int steps, int arrLen) {\n \n return (int) (ways(steps,arrLen,0) % ((Math.pow(10,9)) +7));\n }\n \n public long ways(int steps,int arrLen,int index){\n String curr = index + "->" + steps;\n \n if(index == 0 && steps == 0){\n return 1;\n }else if(index < 0 || (index >= arrLen) || steps == 0){\n return 0;\n }\n \n if(map.containsKey(curr)){\n return map.get(curr);\n }\n long stay = ways(steps-1,arrLen,index);\n long right = ways(steps-1,arrLen,index+1);\n long left = ways(steps-1,arrLen,index-1);\n \n map.put(curr , (stay+right+left) % 1000000007);\n \n return (right + left + stay) % 1000000007;\n }\n}\n | 11 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'Java'] | 3 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++, DP (memoization) with intuition and memory savings, 4ms | c-dp-memoization-with-intuition-and-memo-598t | This task is very similar to the classic question about the number of steps to reach the top:\n70. Climbing Stairs\n\nLet\'s simplify the quesion. How can we re | savvadia | NORMAL | 2019-11-24T09:20:32.386103+00:00 | 2019-11-24T09:23:11.411415+00:00 | 1,011 | false | This task is very similar to the classic question about the number of steps to reach the top:\n[70. Climbing Stairs](https://leetcode.com/problems/climbing-stairs/)\n\nLet\'s simplify the quesion. How can we reach the current position in 1 step?\n - come from left cell\n - come from right cell\n - stay in this cell\n\nThe total number of ways is the sum of these 3 ways for the previous step.\nWe should repeat this for each cell and each step. \n \nWe start with just 1 known way (to be in cell 0) and then step by step build up the knowledge.\n\n```\n#define MAXVAL 1000000007\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n arrLen = min(arrLen, 1+steps/2); // to have time for the way back\n vector<vector<int>> dp(steps+1,vector<int>(arrLen,0));\n dp[0][0]=1;\n for(int s=1; s<steps+1; s++) {\n int depth = min(arrLen, steps-s+1); // to have time for the way back\n for(int pos=0; pos<depth; pos++) {\n int res = dp[s-1][pos] + (pos>0?dp[s-1][pos-1]:0);\n res%=MAXVAL;\n res+= pos<arrLen-1?dp[s-1][pos+1]:0;\n dp[s][pos] = res%MAXVAL;\n }\n }\n return dp[steps][0];\n\t}\n};\n```\nOn each step we need knowledge only about the previous step, so we can keep just the previous step.\n```\n#define MAXVAL 1000000007\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n arrLen = min(arrLen, 1+steps/2);\n vector<int> dp(arrLen,0), prev(arrLen,0);\n prev[0]=1;\n for(int s=1; s<steps+1; s++) {\n int depth = min(arrLen, steps-s+1);\n for(int pos=0; pos<depth; pos++) {\n int res = prev[pos] + (pos>0?prev[pos-1]:0);\n res%=MAXVAL;\n res+= pos<arrLen-1?prev[pos+1]:0;\n dp[pos] = res%MAXVAL;\n }\n swap(dp,prev);\n }\n return prev[0];\n }\n};\n```\n | 11 | 1 | ['Dynamic Programming', 'Memoization'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅ 92.86% DP Optimized | 9286-dp-optimized-by-vanamsen-bvnx | Intuition\nInitially, when we read the problem, it appears to be a classical dynamic programming problem involving movements on a grid or array. At each step, w | vanAmsen | NORMAL | 2023-10-15T11:52:10.875818+00:00 | 2023-10-15T12:50:21.710085+00:00 | 355 | false | # Intuition\nInitially, when we read the problem, it appears to be a classical dynamic programming problem involving movements on a grid or array. At each step, we have three choices: to move left, to move right, or to stay in place. However, the problem comes with constraints: \n1. We can\'t move outside the array.\n2. We need to return to the starting point after all the steps.\n\nThis means the further we move away from the starting point, the more steps it\'ll take to return, limiting how far we can actually go.\n\n# Approach\nWe create a dynamic programming table where each entry `dp[i][j]` represents the number of ways to be at index `j` after `i` steps. To compute this value, we consider three possible previous states: \n1. Being at index `j` after `i-1` steps.\n2. Being at index `j-1` (to the left) after `i-1` steps.\n3. Being at index `j+1` (to the right) after `i-1` steps.\n\nGiven this, the recurrence relation is:\n```\ndp[i][j] = dp[i-1][j] + dp[i-1][j-1] + dp[i-1][j+1]\n```\nHowever, we also ensure we don\'t go out of bounds of the array or move too far away from the starting point that we can\'t return in the remaining steps.\n\nTo further optimize the space, we realize that to compute the values for step `i`, we only need values from step `i-1`. Hence, instead of storing values for all steps, we can just store values for two steps: the current step and the previous step. This allows us to swap the arrays for each step, saving memory.\n\n# Complexity\n- Time complexity: The time complexity remains `O(steps * arrLen)`. This is because for each step, we iterate through the possible positions in the array.\n \n- Space complexity: The space complexity is reduced to `O(arrLen)` from the initial `O(steps * arrLen)` after the optimization. We only maintain two arrays of size `arrLen` instead of a 2D array of size `steps x arrLen`.\n\n# Code\n``` Python []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n mod = 10**9 + 7\n maxColumn = min(arrLen, steps // 2 + 1) # Boundary to ensure we can come back\n \n curr = [0] * (maxColumn + 1)\n prev = [0] * (maxColumn + 1)\n prev[0] = 1\n \n for i in range(1, steps + 1):\n for j in range(maxColumn + 1):\n curr[j] = prev[j]\n if j - 1 >= 0:\n curr[j] = (curr[j] + prev[j-1]) % mod\n if j + 1 < maxColumn:\n curr[j] = (curr[j] + prev[j+1]) % mod\n curr, prev = prev, curr # Swap arrays for the next iteration\n \n return prev[0]\n```\n``` Rust []\nimpl Solution {\n pub fn num_ways(steps: i32, arr_len: i32) -> i32 {\n const MOD: i32 = 1_000_000_007;\n let max_column = std::cmp::min(arr_len, steps / 2 + 1);\n let mut curr = vec![0; (max_column + 1) as usize];\n let mut prev = vec![0; (max_column + 1) as usize];\n prev[0] = 1;\n \n for _ in 1..=steps {\n for j in 0..=max_column as usize {\n curr[j] = prev[j];\n if j >= 1 {\n curr[j] = (curr[j] + prev[j-1]) % MOD;\n }\n if j + 1 < max_column as usize {\n curr[j] = (curr[j] + prev[j+1]) % MOD;\n }\n }\n std::mem::swap(&mut curr, &mut prev);\n }\n prev[0]\n }\n}\n```\n``` Go []\nfunc numWays(steps int, arrLen int) int {\n mod := 1000000007\n maxColumn := min(arrLen, steps/2 + 1)\n curr := make([]int, maxColumn + 1)\n prev := make([]int, maxColumn + 1)\n prev[0] = 1\n \n for i := 1; i <= steps; i++ {\n for j := 0; j <= maxColumn; j++ {\n curr[j] = prev[j]\n if j - 1 >= 0 {\n curr[j] = (curr[j] + prev[j-1]) % mod\n }\n if j + 1 < maxColumn {\n curr[j] = (curr[j] + prev[j+1]) % mod\n }\n }\n curr, prev = prev, curr\n }\n return prev[0]\n}\n\nfunc min(a, b int) int {\n if a < b {\n return a\n }\n return b\n}\n```\n``` C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n const int mod = 1e9 + 7;\n int maxColumn = std::min(arrLen, steps / 2 + 1);\n \n std::vector<int> curr(maxColumn + 1, 0);\n std::vector<int> prev(maxColumn + 1, 0);\n prev[0] = 1;\n \n for(int i = 1; i <= steps; ++i) {\n for(int j = 0; j <= maxColumn; ++j) {\n curr[j] = prev[j];\n if(j - 1 >= 0) {\n curr[j] = (curr[j] + prev[j-1]) % mod;\n }\n if(j + 1 < maxColumn) {\n curr[j] = (curr[j] + prev[j+1]) % mod;\n }\n }\n std::swap(curr, prev);\n }\n return prev[0];\n }\n};\n```\n``` Java []\npublic class Solution {\n public int numWays(int steps, int arrLen) {\n int mod = 1_000_000_007;\n int maxColumn = Math.min(arrLen, steps / 2 + 1);\n int[] curr = new int[maxColumn + 1];\n int[] prev = new int[maxColumn + 1];\n prev[0] = 1;\n\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxColumn; j++) {\n curr[j] = prev[j];\n if (j - 1 >= 0) {\n curr[j] = (curr[j] + prev[j - 1]) % mod;\n }\n if (j + 1 < maxColumn) {\n curr[j] = (curr[j] + prev[j + 1]) % mod;\n }\n }\n System.arraycopy(curr, 0, prev, 0, maxColumn + 1);\n }\n return prev[0];\n }\n}\n```\n``` JavaScript []\nvar numWays = function(steps, arrLen) {\n const mod = 1e9 + 7;\n let maxColumn = Math.min(arrLen, Math.floor(steps / 2) + 1);\n let curr = new Array(maxColumn + 1).fill(0);\n let prev = new Array(maxColumn + 1).fill(0);\n prev[0] = 1;\n\n for (let i = 1; i <= steps; i++) {\n for (let j = 0; j <= maxColumn; j++) {\n curr[j] = prev[j];\n if (j - 1 >= 0) {\n curr[j] = (curr[j] + prev[j - 1]) % mod;\n }\n if (j + 1 < maxColumn) {\n curr[j] = (curr[j] + prev[j + 1]) % mod;\n }\n }\n [curr, prev] = [prev, curr];\n }\n return prev[0];\n};\n```\n``` PHP []\nclass Solution {\n function numWays($steps, $arrLen) {\n $mod = 1000000007;\n $maxColumn = min($arrLen, intval($steps / 2) + 1);\n $curr = array_fill(0, $maxColumn + 1, 0);\n $prev = array_fill(0, $maxColumn + 1, 0);\n $prev[0] = 1;\n\n for ($i = 1; $i <= $steps; $i++) {\n for ($j = 0; $j <= $maxColumn; $j++) {\n $curr[$j] = $prev[$j];\n if ($j - 1 >= 0) {\n $curr[$j] = ($curr[$j] + $prev[$j - 1]) % $mod;\n }\n if ($j + 1 < $maxColumn) {\n $curr[$j] = ($curr[$j] + $prev[$j + 1]) % $mod;\n }\n }\n list($curr, $prev) = array($prev, $curr);\n }\n return $prev[0];\n }\n}\n```\n``` C# []\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n int mod = 1_000_000_007;\n int maxColumn = Math.Min(arrLen, steps / 2 + 1);\n int[] curr = new int[maxColumn + 1];\n int[] prev = new int[maxColumn + 1];\n prev[0] = 1;\n\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxColumn; j++) {\n curr[j] = prev[j];\n if (j - 1 >= 0) {\n curr[j] = (curr[j] + prev[j - 1]) % mod;\n }\n if (j + 1 < maxColumn) {\n curr[j] = (curr[j] + prev[j + 1]) % mod;\n }\n }\n var temp = curr;\n curr = prev;\n prev = temp;\n }\n return prev[0];\n }\n}\n```\n\n## Performance\n\n| Language | Time (ms) | Memory |\n|------------|----------|----------|\n| Go | 3 ms | 2 MB |\n| Rust | 3 ms | 2.2 MB |\n| Java | 6 ms | 39.1 MB |\n| C++ | 16 ms | 6.5 MB |\n| C# | 30 ms | 26.6 MB |\n| PHP | 40 ms | 19 MB |\n| JavaScript | 72 ms | 42 MB |\n| Python3 | 174 ms | 16.3 MB |\n\n# What we learned\n- Dynamic programming can be used to solve problems involving choices at each step.\n- Space optimization is crucial in problems with large input sizes. By observing patterns and dependencies in our DP table, we can often reduce the amount of memory used.\n- Recurrence relations define the relationship between the current state and previous states in dynamic programming. They are essential in understanding and deriving the logic behind the solution. | 10 | 0 | ['PHP', 'C++', 'Java', 'Go', 'Python3', 'Rust', 'JavaScript', 'C#'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | DP - Line by Line Explanation | dp-line-by-line-explanation-by-tr1nity-7mrk | Please check out LeetCode The Hard Way for more solution explanations and tutorials. If you like it, please give a star and watch my Github Repository. Link in | __wkw__ | NORMAL | 2023-10-15T03:25:14.320791+00:00 | 2023-10-15T16:44:15.536650+00:00 | 570 | false | Please check out LeetCode The Hard Way for more solution explanations and tutorials. If you like it, please give a star and watch my Github Repository. Link in bio.\n\n---\n\nThe first observation is that the computational complexity does not depend on `arrLen`, only the steps and position matter. If we have `n` steps, we can only walk at most `n / 2` steps to the left or the right. Therefore, we can use DFS with memoization to find out the answer.\n\n```cpp\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int M = 1e9 + 7;\n // dp[i][j]: how many ways to reach i-th pos using j steps\n vector<vector<int>> dp(steps / 2 + 1, vector<int>(steps + 1, -1));\n function<long long(int,int)> dfs = [&](int pos, int steps) -> long long {\n // if we walk outside the array or use all the steps\n // then return 0\n if (pos < 0 || pos > arrLen - 1 || pos > steps) return 0;\n // if we use all the steps, return 1 only if pos is 0\n if (steps == 0) return pos == 0;\n // if it has been calculated, return directly\n if (dp[pos][steps] != -1) return dp[pos][steps];\n // memoize it\n return dp[pos][steps] = (\n // move to the left\n dfs(pos - 1, steps - 1) % M + \n // stay at current position\n dfs(pos, steps - 1) % M + \n // move to the right\n dfs(pos + 1, steps - 1) % M\n ) % M;\n };\n return dfs(0, steps);\n }\n};\n```\n\n**Python version**\n\n```py\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n M = 10 ** 9 + 7\n @lru_cache(None)\n def dfs(pos, steps):\n # if we walk outside the array or use all the steps\n # then return 0\n if pos < 0 or pos > steps or pos > arrLen - 1: return 0\n # if we use all the steps, return 1 only if pos is 0\n if steps == 0: return pos == 0\n return (\n # move to the left\n dfs(pos - 1, steps - 1) +\n # stay at current position\n dfs(pos, steps - 1) +\n # move to the right\n dfs(pos + 1, steps - 1) \n ) % M\n return dfs(0, steps)\n``` | 10 | 0 | ['Dynamic Programming', 'Memoization', 'C', 'Python'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java DP solution (< 20 lines) with detailed explanation. Please comments if it can improve. | java-dp-solution-20-lines-with-detailed-xysci | // \n// dp[arrLen][steps].\n// There are basically three ways to at index j and step i. They are\n// 1 stay at index j. Contribution from dp[j][i-1];\n// 2 move | liyun1988 | NORMAL | 2019-11-24T04:01:57.163176+00:00 | 2019-11-24T17:20:14.709121+00:00 | 1,309 | false | // \n// dp[arrLen][steps].\n// There are basically three ways to at index j and step i. They are\n// 1 stay at index j. Contribution from dp[j][i-1];\n// 2 move right from index j-1. Contribution from dp[j-1][i-1].\n// 3 move left from index j+1. Contribution from dp[j+1][i-1].\n\n// Optimizations:\n// 1 rolling matrix to avoid abusing the memory.\n// 2 earlier exist when reaching the regions of all zeros.\n// 3 credit to @allenlipeng47, we can get rid of the edge checks by adding a dummy indices to represent -1 and arrLen edges.\n\n\n```\n\n\nclass Solution {\n private int mod = 1000000007;\n public int numWays(int steps, int arrLen) {\n int[][] dp = new int[arrLen+2][2];\n dp[1][0] = 1;\n \n for(int i = 1; i <= steps; ++i) {\n for(int j = 1; j <= arrLen; ++j) {\n // stay\n dp[j][i%2] = (dp[j][(i-1)%2]) % this.mod; \n // move right.\n dp[j][i%2] = (dp[j][i%2] + dp[j-1][(i-1)%2]) % this.mod; \n // move left\n dp[j][i%2] = (dp[j][i%2] + dp[j+1][(i-1)%2]) % this.mod; \n if(dp[j][i%2] == 0) {\n break;\n }\n }\n }\n \n return dp[1][steps%2];\n }\n}\n``` | 10 | 1 | ['Dynamic Programming', 'Java'] | 3 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python 3 || 7 lines, recursion, w/comments || T/S: 75% / 75% | python-3-7-lines-recursion-wcomments-ts-zo4wz | \nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n \n @lru_cache(1000)\n def dp(pos = 0, stepsRem = steps)-> int:\n\n | Spaulding_ | NORMAL | 2023-10-15T02:26:03.578527+00:00 | 2024-06-05T15:50:36.241693+00:00 | 131 | false | ```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n \n @lru_cache(1000)\n def dp(pos = 0, stepsRem = steps)-> int:\n\n if (pos > stepsRem or # too far to get back with steps remaining\n not 0 <= pos < arrLen): # off the array\n return 0\n\n if pos == 0 == stepsRem: # made it to zero\n return 1 # with no steps left\n \n stepsRem-= 1 # decrement step count\n\n return (dp(pos , stepsRem) + # stay\n dp(pos-1, stepsRem) + # step left\n dp(pos+1, stepsRem)) % MOD # step right\n\n return dp()\n```\n[https://leetcode.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps/submissions/1075390479/](https://leetcode.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps/submissions/1075390479/)\n\n\n\nI could be wrong, but I think that time complexity is *O*(*NS*) and space complexity is *O*(*NS*) (because of memoization), in which *N* ~ `n`, and *S* ~ `steps`. | 9 | 0 | ['Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Beats 100%. Python iterative DP solution with explanation. | beats-100-python-iterative-dp-solution-w-h4sb | \n\nclass Solution:\n def numWays(self, steps: int, length: int) -> int:\n # post-loop-invariant:\n\t\t# dp[i] is the number of ways to reach 0 starti | strongerxi | NORMAL | 2019-11-24T07:01:05.296875+00:00 | 2019-11-24T07:01:05.296907+00:00 | 613 | false | ```\n\nclass Solution:\n def numWays(self, steps: int, length: int) -> int:\n # post-loop-invariant:\n\t\t# dp[i] is the number of ways to reach 0 starting from position \'i\',\n # after taking exactly \'step\' steps, where \'step\' is the loop index below\n # It\'s initialized for \'step\' = 0.\n # Note \n # 1. We only need to calculate min(length, steps+1) items. If you draw a\n # data dependency graph in a top-down fashion, you\'ll see why.\n # 2. Last item serves as the left neighbor of position 0, and right\n # neighbor of position length-1. Set to 0 for calculational conveniences.\n needed = min(length, steps + 1)\n dp = [0 for i in range(needed + 1)]\n dp[0] = 1\n # used to avoid unnecessary allocation of lists\n next_dp = dp.copy()\n for step in range(1, steps+1):\n # anything after index=step+1 will be 0, so we don\'t need to access them.\n for pos in range(min(step+1, needed)):\n next_dp[pos]=dp[pos-1]+dp[pos]+dp[pos+1]\n dp, next_dp = next_dp, dp\n return dp[0]%(10**9+7)\n``` | 9 | 0 | [] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 💥💥100% beats runtime and memory [EXPLAINED] | 100-beats-runtime-and-memory-explained-b-xfzl | Intuition\nThe goal is to find how many ways we can stay at index 0 after taking a certain number of steps, where each step allows us to move left, right, or st | r9n | NORMAL | 2024-09-19T19:47:38.431704+00:00 | 2024-09-19T19:47:38.431737+00:00 | 20 | false | # Intuition\nThe goal is to find how many ways we can stay at index 0 after taking a certain number of steps, where each step allows us to move left, right, or stay in place. The key is to realize that after each step, our position depends on where we were in the previous step. The more steps we take, the more positions we can reach, but we want to limit unnecessary moves to stay within bounds and focus on efficient calculations.\n\n\n# Approach\nUse dynamic programming to track how many ways we can reach each position after each step.\n\n\nStart at position 0 with 1 way.\n\n\nFor each step, update ways to move left, right, or stay, but only calculate for relevant positions to save space.\n\n\nAfter all steps, return the number of ways to be at position 0.\n\n# Complexity\n- Time complexity:\nO(steps\xD7min(steps,arrLen)).\n\n- Space complexity:\nO(min(steps,arrLen)).\n\n# Code\n```csharp []\nclass Solution {\n public int NumWays(int steps, int arrLen) {\n const int MOD = 1000000007;\n int maxPos = Math.Min(steps / 2, arrLen - 1);\n int[] dp = new int[maxPos + 1];\n dp[0] = 1;\n\n for (int step = 1; step <= steps; step++) {\n int[] newDp = new int[maxPos + 1];\n for (int pos = 0; pos <= maxPos; pos++) {\n newDp[pos] = dp[pos];\n if (pos > 0) newDp[pos] = (newDp[pos] + dp[pos - 1]) % MOD;\n if (pos < maxPos) newDp[pos] = (newDp[pos] + dp[pos + 1]) % MOD;\n }\n dp = newDp;\n }\n\n return dp[0];\n }\n}\n\n``` | 7 | 0 | ['C#'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 3 choices-dp(take or not take) | 3-choices-dptake-or-not-take-by-priyansh-t83o | Intuition\nFrom the question one can see that there are 3 choices-right,left,stay\nit clearly hints for dp i.e take or not take from the given choices.\n\n\n# C | priyanshulomesh | NORMAL | 2023-10-15T12:27:30.795144+00:00 | 2023-10-15T12:27:30.795162+00:00 | 54 | false | # Intuition\nFrom the question one can see that there are 3 choices-right,left,stay\nit clearly hints for dp i.e take or not take from the given choices.\n\n\n# Complexity\n- Time complexity:\nO(n^2)\n\n- Space complexity:\nO(n^2)\n\n# Code\n```\nclass Solution {\n int mod=1000000007;\n public int solve(int i,int steps,int arrLen,int[][] dp)\n {\n if(i<0||i>arrLen||steps<0)\n {\n return 0;\n }\n\n if(steps==0&&i==0)\n {\n return 1;\n }\n if(dp[i][steps]!=-1)\n {\n return dp[i][steps];\n }\n int left=0,right=0,stay=0;\n \n left=solve(i-1,steps-1,arrLen,dp);\n right=solve(i+1,steps-1,arrLen,dp);\n stay=solve(i,steps-1,arrLen,dp);\n\n return dp[i][steps]=((right+left)%mod+stay)%mod;\n }\n public int numWays(int steps, int arrLen) {\n arrLen=Math.min(steps,arrLen);\n int[][] dp = new int[arrLen+1][steps + 1];\n for (int i = 0; i < arrLen; i++) \n {\n for (int j = 0; j <= steps; j++) \n {\n dp[i][j] = -1;\n }\n }\n return solve(0,steps,arrLen,dp);\n }\n}\n``` | 7 | 0 | ['Java'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Python] The problem description gives away its solution | python-the-problem-description-gives-awa-43r7 | At each step, you can move 1 position to the left, 1 position to the right in the array or stay in the same place (The pointer should not be placed outside the | lamnguyen2187 | NORMAL | 2019-11-24T04:30:55.311622+00:00 | 2019-11-24T04:30:55.311658+00:00 | 366 | false | `At each step, you can move 1 position to the left, 1 position to the right in the array or stay in the same place (The pointer should not be placed outside the array at any time)`\n\nBasically, at an index `idx`, there are potentially 3 cases:\n1. Moving left if `idx-1 >= 1`\n2. Moving right if `idx < arrLen-1`\n3. Stay put\n\nPython code\n```\nimport functools\n\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n @functools.lru_cache(None)\n def solve(n, idx):\n if n == steps:\n return idx == 0\n ans = 0\n if idx > 0:\n ans += solve(n+1, idx-1)\n if idx < arrLen-1:\n ans += solve(n+1, idx+1)\n \n ans += solve(n+1, idx)\n return ans\n mod = 10**9 + 7\n return solve(0, 0) % mod\n``` | 7 | 0 | [] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Video Solution | Java C++ Python | video-solution-java-c-python-by-jeevanku-zunu | \n\n\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int m = (int) 1e9 + 7;\n arrLen = Math.min(arrLen, steps);\n int[ | jeevankumar159 | NORMAL | 2023-10-15T03:40:39.439053+00:00 | 2023-10-15T03:40:39.439076+00:00 | 534 | false | <iframe width="560" height="315" src="https://www.youtube.com/embed/G2jNjuT4Hw8?si=YWjzjgksw_jQTQSJ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>\n\n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int m = (int) 1e9 + 7;\n arrLen = Math.min(arrLen, steps);\n int[][] dp = new int[arrLen][steps + 1];\n dp[0][0] = 1;\n int ans;\n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = 0; curr<arrLen; curr++) {\n ans = dp[curr][remain - 1];\n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % m;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % m;\n }\n \n dp[curr][remain] = ans;\n }\n } \n return dp[0][steps];\n }\n}\n```\n\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n m = 10 ** 9 + 7\n arrLen = min(arrLen, steps + 1)\n dp = [[0] * (steps + 1) for _ in range(arrLen)]\n dp[0][0] = 1\n\n for remain in range(1, steps + 1):\n for curr in range(arrLen):\n ans = dp[curr][remain - 1]\n \n if curr > 0:\n ans = (ans + dp[curr - 1][remain - 1]) % m\n\n if curr < arrLen - 1:\n ans = (ans + dp[curr + 1][remain - 1]) % m\n\n dp[curr][remain] = ans\n\n return dp[0][steps]\n\n```\n\n```\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n const int m = 1e9 + 7;\n arrLen = min(arrLen, steps + 1);\n vector<vector<int>> dp(arrLen, vector<int>(steps + 1, 0));\n dp[0][0] = 1;\n\n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = 0; curr < arrLen; curr++) {\n int ans = dp[curr][remain - 1];\n\n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % m;\n }\n\n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % m;\n }\n\n dp[curr][remain] = ans;\n }\n }\n\n return dp[0][steps];\n }\n};\n\n```\n\n\n | 6 | 0 | ['C', 'Python', 'Java'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java clean dp solution+ recursion (TLE) example for easy understand | java-clean-dp-solution-recursion-tle-exa-ak54 | \nclass Solution {\n public int numWays(int steps, int arrLen) {\n //max steps is 500, you can only move at most to right 500\n int mod=1000000 | CUNY-66brother | NORMAL | 2020-01-17T17:48:53.289682+00:00 | 2020-01-17T20:43:03.838776+00:00 | 589 | false | ```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n //max steps is 500, you can only move at most to right 500\n int mod=1000000007;\n int dp[][]=new int[steps+1][502];\n dp[0][0]=1; \n for(int step=1;step<dp.length;step++){\n for(int pos=0;pos<dp[0].length;pos++){\n if(pos>step){\n break;\n }\n if(pos==0){\n dp[step][pos]+=dp[step-1][pos];\n dp[step][pos]%=mod;\n dp[step][pos]+=dp[step-1][pos+1];\n dp[step][pos]%=mod;\n }\n else if(pos==arrLen-1){\n dp[step][pos]+=dp[step-1][pos];\n dp[step][pos]%=mod;\n dp[step][pos]+=dp[step-1][pos-1];\n dp[step][pos]%=mod;\n }else{\n dp[step][pos]+=dp[step-1][pos+1];\n dp[step][pos]%=mod;\n dp[step][pos]+=dp[step-1][pos];\n dp[step][pos]%=mod;\n dp[step][pos]+=dp[step-1][pos-1];\n dp[step][pos]%=mod;\n }\n }\n }\n return dp[steps][0];\n }\n}\n\n\n\n/*\n//Recursion example+Solution\n//+1 -1 +0 can not less than 0\n//f(pos,step)\n//f(0,3)=f(1,2)+f(0,2)\n//f(1,2)=f(1,1) + f(0,1)+f(2,1)\n\nclass Solution {\n int len=0;\n public int numWays(int steps, int arrLen) {\n int mod=1000000007;\n this.len=arrLen;\n return f(0,steps);\n }\n public int f(int pos,int step)\n { \n //base condition\n if(step==0){\n if(pos==0){//make sure it is the start position\n return 1;\n }else{\n return 0;\n }\n }\n if(pos==0){\n return f(pos,step-1)+f(pos+1,step-1);\n }\n else if(pos==len-1){\n return f(pos,step-1)+f(pos-1,step-1);\n }else{\n return f(pos,step-1)+f(pos-1,step-1)+f(pos+1,step-1);\n }\n }\n}\n*/\n``` | 6 | 0 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C# | c-by-lightyagami821-uqwg | \n# Code\n\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n int mod = 1000000007;\n \n int maxPosition = Math.Mi | LightYagami821 | NORMAL | 2023-11-19T04:26:01.187442+00:00 | 2023-11-19T04:26:01.187464+00:00 | 27 | false | \n# Code\n```\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n int mod = 1000000007;\n \n int maxPosition = Math.Min(steps / 2, arrLen - 1);\n \n int[][] dp = new int[steps + 1][];\n for (int i = 0; i <= steps; i++) {\n dp[i] = new int[maxPosition + 1];\n }\n \n dp[0][0] = 1;\n \n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j <= maxPosition; j++) {\n dp[i][j] = dp[i - 1][j];\n \n if (j > 0) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n }\n \n if (j < maxPosition) {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n }\n \n return dp[steps][0];\n }\n}\n``` | 5 | 0 | ['C#'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Recursion + Memoization || Easiest explanation || Beginner friendly solution | recursion-memoization-easiest-explanatio-snr3 | Intuition\n Describe your first thoughts on how to solve this problem. \nRecursion.\n\n# Approach\n Describe your approach to solving the problem. \n### BASE CA | BihaniManan | NORMAL | 2023-10-15T08:22:48.872271+00:00 | 2023-10-15T22:29:36.867492+00:00 | 465 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nRecursion.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n### BASE CASES:\n1. If we are on the 0th index, we can\'t make first move as **LEFT**, as it will go out of arrLen, so it\'s our first base case.\n2. Similarly, suppose, steps = 3 and arrLen = 1, our first and second moves can\'t be **RIGHT** and **RIGHT** respectively as it will again go out of the arrLen. So it\'s our second base case.\n3. We obviously can\'t make more moves than assigned in the question, so it\'s our third base case.\n4. When we have made all the steps and are still on the 0th index, at that time return 1.\n\n### Recursion:\n1. There are three parameters in my recursive function, steps, arrLen and index.\n2. When our move is **LEFT**, do steps - 1, and idx - 1.\n3. When our move is **RIGHT**, do steps - 1 and idx + 1.\n4. When our move is **STAY**, do steps - 1 and idx will not change.\n\nOur answer is **LEFT** + **RIGHT** + **STAY**.\n\n\n### Memoization (3rd step is the most important step)\n1. It is important to note the contraints of the problem, the steps are from 1 to 500 which is fine.\n2. arrLen is from 1 to 1e6 which is not at all fine and will definitely give MLE if simply memoized.\n3. Notice that, if arrLen is greater than steps, we are dependent on steps and not the arrLen as at the most we can make all the moves as as we make RIGHT moves arrLen + 1 times, we will be out of the array and we\'ll return 1, so no need to consider rest of the arrLen other than that of steps.\n4. So as our arrLen > steps, do arrLen = steps, now since we have changed the constraints of the problem, and now arrLen is also between 1 and 500, we can easily memoize it using a 2-D vector.\n\n# Complexity\n- Time complexity: **O(n^2)**\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: **O(n^2)**\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\nwhere n is steps.\n\n# Code\n```\nclass Solution {\npublic:\n int MOD = 1e9 + 7;\n int solveMem(int steps, int arrLen, int idx, vector<vector<long long int>> &dp) {\n if(idx < 0 || idx >= arrLen || steps < 0) return 0;\n\n if(idx == 0 && steps == 0) return 1;\n\n if(dp[steps][idx] != -1) return dp[steps][idx];\n\n long long int left = solveMem(steps - 1, arrLen, idx - 1, dp) % MOD;\n long long int right = solveMem(steps - 1, arrLen, idx + 1, dp) % MOD;\n long long int stay = solveMem(steps - 1, arrLen, idx, dp) % MOD;\n\n return dp[steps][idx] = (left + stay + right) % MOD;\n }\n int numWays(int steps, int arrLen) {\n if(arrLen > steps) arrLen = steps;\n vector<vector<long long int>> dp(steps + 1, vector<long long int>(arrLen, -1));\n return solveMem(steps, arrLen, 0, dp);\n }\n};\n``` | 5 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Java] DP Solution with explanation | java-dp-solution-with-explanation-by-xia-ov52 | \nApply dynamic programming to solve the probelm. Use a 2D array dp[steps][index] to count how many possible ways to reach the index i for step s. Notice that | xiaode | NORMAL | 2019-11-24T05:57:40.196257+00:00 | 2019-11-24T17:56:17.031294+00:00 | 430 | false | \nApply dynamic programming to solve the probelm. Use a 2D array `dp[steps][index]` to count how many possible ways to reach the `index i` for `step s`. Notice that the current state only rely on one previous state, so the storage can be optimized to 2 arrays `pre` and `cur`.\nFor recurrence relationship, notice that for each`index i` , the only possible ways to reach `i` are from previous `i-1`, `i+1` and `i`. So we have: `cur[i] = pre[i-1]+pre[i+1]+pre[i]` if `i` is not head or tail.\n\n\n```\nclass Solution {\n public int numWays(int steps, int arrlen) {\n int arrLen = Math.min(steps, arrlen); // optimization, no need for array that oversizes steps\n long[] cur = new long[arrLen]; // use long instead of int to avoid potential overflow\n long[] pre = new long[arrLen]; \n int mod = (int) 1e9+7;\n pre[0] = 1;\n pre[1] = 1;\n for (int i = 1; i < steps; i++) { // start from step 2 actually\n cur = new long[arrLen];\n for (int j = 0; j < arrLen; j++) {\n if (j == 0 || j == arrLen - 1) { // first and last position\n if (j == 0) cur[j] = pre[j]+ pre[j+1];\n else cur[j] = pre[j] + pre[j-1];\n } else {\n cur[j] = (pre[j-1] + pre[j]+ pre[j+1]);\n \n }\n cur[j] %= mod;\n } \n pre = cur;\n \n }\n return (int)cur[0];\n }\n}\n``` | 5 | 0 | ['Dynamic Programming'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | python dp solution | python-dp-solution-by-hong_tao-cg23 | \n## Boundary analysis:\nwhat is the maximum index you can get?\nfirst of all, you cannot get out the array, thus, N is one of the limit.\nAnd, you can move at | hong_tao | NORMAL | 2019-11-24T04:56:13.486809+00:00 | 2019-11-29T03:53:15.835848+00:00 | 335 | false | \n## Boundary analysis:\nwhat is the maximum index you can get?\nfirst of all, you cannot get out the array, thus, N is one of the limit.\nAnd, you can move at most ```steps``` times, so the maxiumu index you can arrive at is min(steps, N), so all possible index you can arrive at is in the range```[0, min(steps, N)]```\n\nwith boundary in mind, the dp solution comes naturely. \n**state:** ```prev[i]```: the number of ways to stay at index ```i``` after moving ```T``` steps.\n**state transition:** move one more step---after moving ```T+1``` steps:\n```cur[i] = prev[i-1] + prev[i] + prev[i+1]```(mind the corner case where i == 0 and i == N-1).\n\n\n## Code\n```\ndef numWays(self, steps: int, N: int) -> int:\n\tl = min(steps, N)\n\tdp = [0] * l\n\tdp[0] = 1\n\tfor _ in range(steps):\n\t\tcur = [0] * l\n\t\tcur[0] = dp[0] + dp[1]\n\t\tcur[-1] = dp[-1]+dp[-2]\n\t\tfor i in range(l):\n\t\t\tcur[i] = dp[i-1] + dp[i] + dp[i+1]\n\t\tdp = cur\n\treturn dp[0] %(10**9+7)\n```\n | 5 | 1 | ['Dynamic Programming', 'Python3'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | My simple JAVA DP solution | my-simple-java-dp-solution-by-lian9-0i6l | class Solution {\n public int numWays(int steps, int arrLen) {\n //DP solution \n if (arrLen == 1) {\n return 1;\n }\n | lian9 | NORMAL | 2019-11-24T04:55:49.432061+00:00 | 2019-11-24T04:55:49.432096+00:00 | 600 | false | class Solution {\n public int numWays(int steps, int arrLen) {\n //DP solution \n if (arrLen == 1) {\n return 1;\n }\n int mod = 1000_000_007;\n int[] dp = new int[arrLen]; //dp[i] represents for current move, how many possible way I can in i-th position\n dp[0] = 1;\n \n for (int i = 1; i <= steps; i++) {\n int[] next = new int[arrLen]; \n for (int j = 0; j < Math.min(arrLen, steps); j++) { //NOTE !!!!! use this min to reduce time complexity\n next[j] = dp[j];\n if (j > 0) {\n next[j] = (next[j] + dp[j - 1]) % mod;\n } \n if (j < arrLen - 1) {\n next[j] = (next[j] + dp[j + 1]) % mod;\n } \n }\n dp = next;\n }\n \n return dp[0];\n }\n} | 5 | 0 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Easy CPP Solution | Memoisation C++ | 2D DP | easy-cpp-solution-memoisation-c-2d-dp-by-tphm | Complexity\n- Time complexity: O(510steps)\n Add your time complexity here, e.g. O(n) \n\n- Space complexity: O(510steps)\n Add your space complexity here, e.g. | saurav_1928 | NORMAL | 2023-10-15T12:14:56.607262+00:00 | 2023-10-15T12:14:56.607285+00:00 | 387 | false | # Complexity\n- Time complexity: O(510*steps)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(510*steps)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public: const int mod = 1e9 + 7;\n long long dp[510][510];\n long long solve(int steps, int n, int ind) {\n /* base case, if we have exhausted all our steps then return 1 only if we are on ind = 0 */\n if (steps == 0) return ind == 0;\n // check if we alredy computed this subproblem\n if (dp[ind][steps] != -1) return dp[ind][steps];\n long long res = 0;\n //check if we can go to right , if possible then go to right\n if (ind + 1 < n) res += solve(steps - 1, n, ind + 1);\n //check if we can go to left , if possible then go to left\n if (ind - 1 >= 0) res += solve(steps - 1, n, ind - 1);\n //stay on same index\n res += solve(steps - 1, n, ind);\n return dp[ind][steps] = res % mod;\n }\n int numWays(int steps, int n) {\n // initialising dp array with -1\n memset(dp, -1, sizeof(dp));\n return (int) solve(steps, n, 0);\n }\n};\n``` | 4 | 0 | ['Dynamic Programming', 'C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Beats 99% | Optimised Solution Using Dynamic Programming | Easy O(steps * maxPosition) Solution | beats-99-optimised-solution-using-dynami-aqi0 | Intuition\n Describe your first thoughts on how to solve this problem. \nThe problem is to count the number of ways to stay at index 0 in an array of length arr | nikkipriya_78 | NORMAL | 2023-10-15T06:23:27.472984+00:00 | 2023-10-15T06:23:27.473005+00:00 | 392 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem is to count the number of ways to stay at index 0 in an array of length arrLen after taking steps steps. You can move one step to the left, one step to the right, or stay in the same place at each step. To solve this problem, dynamic programming can be used to keep track of the number of ways to reach each position at each step.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. Initialize a constant `MOD` for taking the result modulo 10^9 + 7, a variable `maxPosition` as the maximum position to avoid going out of bounds, and a vector `dp` to keep track of the number of ways to reach each position.\n\n2. Initialize `dp[0]` to 1 because initially, you are at position 0 after 0 steps.\n\n3. Use a nested loop to iterate for each step from 1 to `steps`.\n\n4. Inside the nested loop, create a new vector `new_dp` to store the updated values for the number of ways.\n\n5. Iterate for each position j from 0 to `maxPosition`.\n\n6. Update `new_dp[j]` by considering three possibilities:\n\n7. Stay in the same place, which is `dp[j]`.\n\n8. Move one step to the left if `j > 0`, which is `dp[j - 1]`.\n\n9. Move one step to the right if `j < maxPosition`, which is `dp[j + 1]`.\n\n10. Update `dp` to be equal to `new_dp` for the next iteration.\n\n11. After all iterations, the result is stored in `dp[0]`, which represents the number of ways to stay at index 0 after `steps` steps.\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this solution is O(steps * maxPosition), where `steps` is the input number of steps and `maxPosition` is the minimum of `steps / 2` and `arrLen - 1`. In the worst case, this solution has a time complexity of O(steps * min(steps/2, arrLen)).\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity of this solution is O(maxPosition) to store the dynamic programming array `dp` and `new_dp`.\n# Code\n```\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int MOD = 1000000007;\n int maxPosition = min(steps / 2, arrLen - 1);\n vector<long long> dp(maxPosition + 1, 0);\n dp[0] = 1;\n\n for (int i = 1; i <= steps; i++) {\n vector<long long> new_dp(maxPosition + 1, 0);\n for (int j = 0; j <= maxPosition; j++) {\n new_dp[j] = dp[j];\n if (j > 0)\n new_dp[j] = (new_dp[j] + dp[j - 1]) % MOD;\n if (j < maxPosition)\n new_dp[j] = (new_dp[j] + dp[j + 1]) % MOD;\n }\n dp = new_dp;\n }\n return dp[0];\n }\n};\n``` | 4 | 1 | ['Dynamic Programming', 'C', 'Python', 'C++', 'Java', 'Python3', 'Ruby', 'JavaScript'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 🚩📈Beats 99.70% |🔥Easy and Optimised O(sqrt(n)) Approach | 📈Explained in detail | beats-9970-easy-and-optimised-osqrtn-app-k3rj | Intuition\n Describe your first thoughts on how to solve this problem. \nThe idea behind this solution is to recognize that as the number of steps increases, th | saket_1 | NORMAL | 2023-10-15T06:13:34.454644+00:00 | 2023-10-15T06:13:34.454672+00:00 | 565 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe idea behind this solution is to recognize that as the number of steps increases, the number of ways to reach the starting position at index 0 forms a bell curve. This bell curve reaches its peak at the midpoint and then starts to decrease symmetrically. Since moving left or right by one step is symmetric, the number of ways to reach index 0 is determined by the number of ways to reach positions up to the midpoint.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. Initialize a constant `MOD` to 1000000007, which will be used for taking the modulo of intermediate and final results.\n2. Calculate the `maxPosition`, which represents the maximum position that can be reached without going out of bounds. This is determined as the minimum of `steps / 2` and `arrLen - 1`.\n3. Initialize a vector `dp` of size `maxPosition + 1` to keep track of the number of ways to reach each position.\n4. Initialize `dp[0]` to 1, representing that there is one way to stay at index 0 after 0 steps.\n5. Use an iterative approach to calculate the number of ways to reach each position for each step. For each step, update the number of ways for each position based on the previous step\'s values.\n6. Return `dp[0]`, which represents the number of ways to stay at index 0 after `steps` steps.\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity of this solution is O(sqrt(n)), where n is the number of steps. The loop iterates for each step, and for each step, it updates all positions up to the `maxPosition`, which is sqrt(n).\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity is O(maxPosition), which is O(sqrt(n)). This is because we only store the number of ways for positions up to the `maxPosition`.\n# Code\n```\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int MOD = 1000000007;\n int maxPosition = min(steps / 2, arrLen - 1);\n vector<long long> dp(maxPosition + 1, 0);\n dp[0] = 1;\n\n for (int i = 1; i <= steps; i++) {\n vector<long long> new_dp(maxPosition + 1, 0);\n for (int j = 0; j <= maxPosition; j++) {\n new_dp[j] = dp[j];\n if (j > 0)\n new_dp[j] = (new_dp[j] + dp[j - 1]) % MOD;\n if (j < maxPosition)\n new_dp[j] = (new_dp[j] + dp[j + 1]) % MOD;\n }\n dp = new_dp;\n }\n return dp[0];\n }\n};\n\n``` | 4 | 1 | ['Array', 'Math', 'Dynamic Programming', 'Python', 'C++', 'Java', 'Python3', 'Ruby', 'JavaScript'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅ C++ Naive solution Little Optimization | c-naive-solution-little-optimization-by-vrev6 | Intuition\n- Let\'s consider an example with arrLen = 3 and steps = 3. We want to calculate the number of ways to reach each position in the array after taking | Tyrex_19 | NORMAL | 2023-10-15T05:29:55.962249+00:00 | 2023-10-15T07:47:58.974036+00:00 | 330 | false | # Intuition\n- Let\'s consider an example with arrLen = 3 and steps = 3. We want to calculate the number of ways to reach each position in the array after taking the given number of steps.\n\n- At the first step, we have two options: we can either stay at position 0 or move one step forward to position 1. So, our possible ending positions after the first step are [0, 1].\n\n- Moving on to the second step, we compute the possible options from each of the previous step\'s positions:\n\n - Starting from position 0, the possible next positions are [0, 1].\n - Starting from position 1, the possible next positions are [0, 1, 2].\nCombining the results, our final positions after two steps are [0, 0, 1, 1, 2].\n\n- To optimize memory usage, we can represent the results differently. Instead of storing the positions with their duplicates, we can store each unique element and its associated occurrence count. In this case, our result becomes: {0: 2, 1: 2, 2: 1}.\n\n- Now, we can compute the variations for each step:\n\n- Initialization of step 3: {}\n\n - For position 0, we can move to [0, 1]. Since we have two occurrences of 0 in the previous step, the number of possible moves for each element in the array is 2. Therefore, the updated result becomes {0: 2, 1: 2}.\n - For position 1, we can move to [0, 1, 2]. Again, we have two occurrences of 1 in the previous step, so the number of possible moves from 1 for each element is 2. The updated result becomes {0: 2 + 2, 1: 2 + 2, 2: 1} = {0: 4, 1: 4, 2: 2}.\n - For position 2, we can move to [1, 2]. There is one occurrence of position 2 in the previous step, so each of those possible moves will be counted once. The updated result becomes {0: 4, 1: 4 + 1, 2: 2 + 1} = {0: 4, 1: 5, 2: 3}.\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: O(steps * arrLen)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(steps * arrLen)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n const int MOD = 1000000007;\n\npublic:\n int numWays(int steps, int arrLen) {\n vector<unordered_map<int, long long>> vec(steps);\n unordered_map<int, long long> mp, tp;\n mp[0] = 1;\n if(arrLen > 1)\n mp[1] = 1;\n vec[0] = mp;\n for(int i = 1; i < steps; i++){\n mp.clear();\n tp = vec[i-1];\n for(auto it = tp.begin(); it != tp.end(); it++){\n int el = it->first;\n if(el + 1 < arrLen) mp[el+1] = (mp[el+1] + it->second) % MOD;\n if(el - 1 >= 0) mp[el-1] = (mp[el-1] + it->second) % MOD;\n mp[el] = (mp[el] + it->second) % MOD;\n }\n vec[i] = mp;\n }\n return (int)vec[steps - 1][0];\n }\n};\n```\nUpvote if you found it useful.\n\nJoin this Discord server for coding-related discussions: https://discord.gg/kKvjWUmx\n\nhttps://youtu.be/rvTdm28yUjQ | 4 | 0 | ['C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Beats 100%🔥Memory & Runtime🦄7 Lines🔮1D DP✅Python 3 | beats-100memory-runtime7-lines1d-dppytho-i8d1 | \n <img alt="image.png" src="https://assets.leetcode.com/users/images/91bea382-d181-4c75-b6a5-ce2965576fe7_1697349959.2977636.png" /> \n\n\n\n# Complexity\n- Ti | atsreecha | NORMAL | 2023-10-15T02:04:45.834207+00:00 | 2023-10-15T06:08:35.507146+00:00 | 223 | false | \n<!--  -->\n\n\n\n# Complexity\n- Time complexity: `O (arrlen * steps)`\n- Space complexity: `O (n)`\n\n# Code\n```Python []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n n = min(steps//2 + 1, arrLen)\n dp = [1] + [0]*n\n for _ in range(steps):\n prev=0\n for i in range(n):\n dp[i], prev =(prev + dp[i] + dp[i + 1]), dp[i]\n return dp[0] % (10**9+7)\n```\n\n\n> \n\n> _"catphrase"_ | 4 | 0 | ['Dynamic Programming', 'Python', 'Python3'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | JAVA solution faster than 90% and steps to reach the solution (with explanation) | java-solution-faster-than-90-and-steps-t-u401 | Simple recursive approach:\n \n\t recFunc(int stepsLeft, int arrLen, int currentIndex){//i have x steps left and i am currently at position y so in how many | 141200019 | NORMAL | 2021-01-25T18:27:56.634714+00:00 | 2021-02-06T10:25:12.491828+00:00 | 325 | false | * Simple recursive approach:\n ```\n\t recFunc(int stepsLeft, int arrLen, int currentIndex){//i have x steps left and i am currently at position y so in how many ways can i reach position 1\n\t if(stepsLeft==0){ //I have 0 steps left\n\t if(currentIndex==0) return 1; // I am at position 0, so I have met the terms, so return 1\n\t else return 0; // I am at some other position and have no steps to go back. So this is not what we want!\n\t }\n\t if(currentIndex>=arrLen||currentIndex<0) return 0; // check if we are out of bound.\n\t return recFunc(steps-1,arrLen,currentIndex);//I decide to stay\n\t + recFunc(steps-1,arrLen,currentIndex+1);//I decide to move right\n\t + recFunc(steps-1,arrLen,currentIndex-1);//I decide to move left\n\t }\n\t ```\n\t \n\t\n* \tlooking at this we can create our dp:\n So our result depends upon our current position in the array and how many steps we are left with. So out dp should be: ```dp[steps][currentIndex]```\n\t\t ```\n\t\t dp[steps][currentIndex]=dp[steps-1][currentIndex]+dp[steps-1][currentIndex+1]+dp[steps-1][currentIndex-1]\n\t\t ```\n\t\t \n\t\t base conition: if we have 0 steps left only if we are at 0th position only then we can meet the requirement. so ```dp[0][0]=1```\n\t\t \n\t\t \n* Memory optimization:\n we don\'t need information about all the steps, we just need information about current step-1 , and that too just three values, current value (which is already stored), next value(this is also already stored), previous value(this we need to save)\n\t ```\n\t int current=dp[currentIndex];\n\t\t dp[currentIndex]=prev+dp[currentIndex+1]+dp[currentIndex];\n\t\t prev=current;\n\t\t ```\n\n* Time optimization:\n if we have reached a step where calculation of ans for current index is 0, there is no way with same steps we can reach index 0 from position ahead of that. so break when dp[currentIndex]==0\n\t\n\t\n\t\n* \tfinal Approach:\n\t\n\t```\n\tclass Solution {\n int mod=1000000007;\n public int numWays(int steps, int arrLen) {\n \n int[]dp= new int[arrLen];\n dp[0]=1;\n for(int i=1;i<=steps;i++){\n int prev=0;\n l1: for(int j=0;j<arrLen;j++){\n int x=dp[j];\n dp[j]+=prev;\n dp[j]%=1000000007;\n \n if(j<arrLen-1){\n dp[j]+=dp[j+1];\n dp[j]%=1000000007;\n }\n if(dp[j]==0)break l1;\n prev=x;\n }\n }\n return dp[0];\n }\n}\n```\n | 4 | 1 | [] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | DP with memoization approach - C++ | dp-with-memoization-approach-c-by-eduthe-flkt | Intuition\nTo solve this problem we can use Dynamic Prgramming. We can create a function called f(i, step), where the intuition behind it is to determine the nu | edutheodoro | NORMAL | 2023-10-25T16:56:12.368941+00:00 | 2023-10-25T16:56:12.368973+00:00 | 9 | false | # Intuition\nTo solve this problem we can use Dynamic Prgramming. We can create a function called f(i, step), where the intuition behind it is to determine the number of ways to reach position 0 after a certain number of steps while respecting certain constraints.\n\n- i represents the current position in the array.\n- step represents the number of steps taken.\n\n# Approach\n- Memo is a 2D array of integers with dimensions 251x501 (position x steps). **We can see that since $$steps <= 500$$, we cannot go further than $250$ positions, otherwise we wouldn\'t be able to return to position 0.** This array is used for memoization to store precomputed results and avoid redundant calculations. Memoization is a common technique used to optimize recursive algorithms.\n\n- const int mod = 1e9 + 7; defines a constant integer to represent the modulo value. The final result will be taken modulo this value to ensure that it doesn\'t exceed a certain limit.\n\n- The f function is a recursive helper function that computes the number of ways to reach position 0 after a certain number of steps while staying within the defined constraints.\n\n1. **i** represents the current position in the array and **step** represents the number of steps taken so far. In the function:\n\n2. If i is out of bounds (either greater than maxL or less than 0), it returns 0 because this is not a valid way to reach the destination.\n\n3. If step is equal to n, it checks if the current position is back at 0. If it is, it returns 1 (a valid way); otherwise, it returns 0.\n\n4. Memoization is employed to avoid redundant calculations. If the result for a specific (i, step) combination has been calculated before, it is returned from the memo array.\n\n5. If the result is not memoized, it calculates the number of ways recursively:\n\n - Move one step to the right, resulting in a call to f(i + 1, step + 1).\n - Stay in the same position, resulting in a call to f(i, step + 1).\n - Move one step to the left, resulting in a call to f(i - 1, step + 1).\n\n6. The results of these three recursive calls are summed up, and the final result is taken modulo mod. This result is stored in the memo array for future reference.\n\n- The numWays function sets up the initial values, including maxL, n, and memoization. It then calls the f function with an initial position of 0 and 0 steps taken to start the recursive calculation.\n\n# Complexity\n- Time complexity: $$O(steps\xB2)$$\n\n- Space complexity: $$O(steps\xB2)$$ \n\n# Code\n```\nclass Solution {\npublic:\n\n int memo[251][501];\n const int mod = 1e9 + 7;\n int maxL;\n int n;\n\n int f(int i, int step){\n if(i > maxL || i < 0) return 0;\n if(step == n) return i == 0;\n if(memo[i][step]!=-1) return memo[i][step];\n \n int ans = f(i+1, step+1)%mod;\n ans = (ans + f(i, step+1))%mod;\n ans = (ans + f(i-1, step+1))%mod;\n\n return memo[i][step] = ans;\n }\n\n int numWays(int steps, int arrLen) {\n maxL = min((int)ceil(steps/2.0), arrLen -1);\n n = steps;\n memset(memo, -1, sizeof memo);\n\n return f(0, 0);\n }\n};\n``` | 3 | 0 | ['Dynamic Programming', 'Memoization', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | DP || Memoization || Self-Explanatory || Very Easy || Intuitive🔥🔥✅✅ | dp-memoization-self-explanatory-very-eas-iqus | Code\n\nclass Solution {\npublic:\n int mod = 1e9+7;\n map<pair<int,int>,int>dp;\n int solve(int steps,int arrlen,int currsteps,int currind){\n | snehagoyal20 | NORMAL | 2023-10-15T11:50:25.830562+00:00 | 2023-10-15T11:50:25.830587+00:00 | 176 | false | # Code\n```\nclass Solution {\npublic:\n int mod = 1e9+7;\n map<pair<int,int>,int>dp;\n int solve(int steps,int arrlen,int currsteps,int currind){\n if(currsteps == steps){\n return (currind == 0)? 1 : 0;\n }\n if(currind < 0 || currind >= arrlen)return 0;\n\n if(dp.find({currsteps,currind}) != dp.end())return dp[{currsteps,currind}];\n int right = 0, left = 0, stay = 0;\n right = solve(steps,arrlen,currsteps+1,currind+1);\n left = solve(steps,arrlen,currsteps+1,currind-1);\n stay = solve(steps,arrlen,currsteps+1,currind);\n\n return dp[{currsteps,currind}] = ((right+left)%mod+stay)%mod;\n }\n int numWays(int steps, int arrLen) {\n return solve(steps,arrLen,0,0);\n }\n};\n``` | 3 | 0 | ['Dynamic Programming', 'Memoization', 'C++'] | 2 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Mastering Dynamic Programming: Counting Ways to Reach a Position in an Array | mastering-dynamic-programming-counting-w-pphr | Counting Ways to Reach a Position in an Array\n\n## Approach 1: Recursion\n\n### Explanation\nIn this approach, we\'ll use a recursive function to explore all p | LakshayBrejwal_1_0 | NORMAL | 2023-10-15T08:36:40.044972+00:00 | 2023-10-15T08:36:40.044997+00:00 | 85 | false | # Counting Ways to Reach a Position in an Array\n\n## Approach 1: Recursion\n\n### Explanation\nIn this approach, we\'ll use a recursive function to explore all possible ways to reach a specific position in an array after a given number of steps. The key idea is to consider three options at each step: staying in the current position, moving one step to the right, or moving one step to the left. We\'ll use recursion to explore all these possibilities.\n\n### Dry Run\nLet\'s consider an example: we want to find the number of ways to reach position 2 in an array after 3 steps. We\'ll start with `Recursion_Solution(3, arrLen, 2)`.\n\n1. At step 3, we have 3 options:\n - Stay in the current position: `Recursion_Solution(2, arrLen, 2)`\n - Move one step to the right: `Recursion_Solution(2, arrLen, 3)`\n - Move one step to the left: `Recursion_Solution(2, arrLen, 1)`\n\n2. We continue this process, exploring all possibilities until we reach the base cases:\n - If steps = 0 and pos = 0, return 1.\n - If steps = 0 and pos is not 0, return 0.\n - If steps become negative or pos goes out of bounds, return 0.\n\n3. The total count of ways to reach position 2 after 3 steps is the sum of all possibilities.\n\n### Edge Cases\n- We need to handle cases where the number of steps becomes negative or the position goes out of bounds.\n\n### Complexity Analysis\n- Time Complexity: O(3^steps) in the worst case, where "steps" is the number of steps.\n- Space Complexity: O(steps) for the recursion stack.\n\n### Codes : \n```cpp []\nstatic int MOD = 1e9 + 7;\nclass Solution\n{\n public:\n int Recursion_Solution(int steps, int arrLen, int pos)\n {\n if (steps == 0 and pos == 0) return 1;\n if (steps == 0 and pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n return (Recursion_Solution(steps - 1, arrLen, pos) % MOD // stay\n + Recursion_Solution(steps - 1, arrLen, pos + 1) % MOD // right\n + Recursion_Solution(steps - 1, arrLen, pos - 1) % MOD); // left\n }\n\n int numWays(int steps, int arrLen)\n {\n return Recursion_Solution(steps, arrLen, 0);\n }\n};\n```\n\n```java []\nclass Solution {\n private static final int MOD = 1000000007;\n\n public int Recursion_Solution(int steps, int arrLen, int pos) {\n if (steps == 0 && pos == 0) return 1;\n if (steps == 0 && pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n return (Recursion_Solution(steps - 1, arrLen, pos) % MOD // stay\n + Recursion_Solution(steps - 1, arrLen, pos + 1) % MOD // right\n + Recursion_Solution(steps - 1, arrLen, pos - 1) % MOD); // left\n }\n\n public int numWays(int steps, int arrLen) {\n return Recursion_Solution(steps, arrLen, 0);\n }\n}\n```\n\n\n```python []\nMOD = 10**9 + 7\n\nclass Solution:\n def Recursion_Solution(self, steps, arrLen, pos):\n if steps == 0 and pos == 0:\n return 1\n if steps == 0 and pos != 0:\n return 0\n if steps < 0 or pos < 0 or pos >= arrLen:\n return 0\n return (self.Recursion_Solution(steps - 1, arrLen, pos) % MOD # stay\n + self.Recursion_Solution(steps - 1, arrLen, pos + 1) % MOD # right\n + self.Recursion_Solution(steps - 1, arrLen, pos - 1) % MOD) # left\n\n def numWays(self, steps, arrLen):\n return self.Recursion_Solution(steps, arrLen, 0)\n```\n\n\n```javascript []\ncvar MOD = 1000000007;\n\nvar Recursion_Solution = function (steps, arrLen, pos) {\n if (steps === 0 && pos === 0) return 1;\n if (steps === 0 && pos !== 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n return (\n (Recursion_Solution(steps - 1, arrLen, pos) % MOD) + // stay\n (Recursion_Solution(steps - 1, arrLen, pos + 1) % MOD) + // right\n (Recursion_Solution(steps - 1, arrLen, pos - 1) % MOD)\n ); // left\n};\n\nvar numWays = function (steps, arrLen) {\n return Recursion_Solution(steps, arrLen, 0);\n};\n\n```\n\n```csharp []\npublic class Solution {\n private static int MOD = 1000000007;\n\n public int Recursion_Solution(int steps, int arrLen, int pos) {\n if (steps == 0 && pos == 0) return 1;\n if (steps == 0 && pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n return (Recursion_Solution(steps - 1, arrLen, pos) % MOD // stay\n + Recursion_Solution(steps - 1, arrLen, pos + 1) % MOD // right\n + Recursion_Solution(steps - 1, arrLen, pos - 1) % MOD); // left\n }\n\n public int NumWays(int steps, int arrLen) {\n return Recursion_Solution(steps, arrLen, 0);\n }\n}\n```\n\n\n---\n\n## Approach 2: Top-Down Dynamic Programming\n\n### Explanation\nIn this approach, we\'ll use top-down dynamic programming to solve the problem. We\'ll maintain a 2D array `dp` to store the number of ways to reach a specific position in the array. We\'ll use recursion to calculate these values based on three possible moves: stay, move right, and move left. We\'ll apply modular arithmetic to handle large numbers.\n\n### Dry Run\nLet\'s run a dry run example to illustrate how the approach works.\n\nFor `steps = 3` and `arrLen = 2`, the `dp` array might look like this:\n\n```\n[[1, 0, -1], // Step 0\n [1, -1, -1], // Step 1\n [1, -1, -1]] // Step 2\n```\n\nHere, we start at position 0, and after 3 steps, we have 1 way to reach position 0.\n\n### Edge Cases\n- If `steps` is 0 and `pos` is 0, return 1.\n- If `steps` is 0 and `pos` is not 0, return 0.\n- If `steps` is negative or `pos` is out of bounds, return 0.\n\n### Complexity Analysis\n- Time Complexity: O(steps * min(steps, min(steps,arrLen))) as we fill the `dp` array.\n- Space Complexity: O(steps * min(steps, min(steps,arrLen))) for the `dp` array.\n\n### Codes \n\n```cpp []\nstatic int MOD = 1e9 + 7;\n\nclass Solution {\npublic:\n int TopDown(int steps, int arrLen, int pos, vector<vector<int>>& dp) {\n if (steps == 0 && pos == 0) return 1;\n if (steps == 0 && pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n if (dp[steps][pos] != -1) return dp[steps][pos];\n return dp[steps][pos] = ((TopDown(steps - 1, arrLen, pos, dp) % MOD // stay\n + TopDown(steps - 1, arrLen, pos + 1, dp) % MOD) % MOD // right\n + TopDown(steps - 1, arrLen, pos - 1, dp) % MOD) % MOD; // left\n }\n\n int numWays(int steps, int arrLen) {\n vector<vector<int>> dp(steps + 1, vector<int>(steps+2, -1));\n return TopDown(steps, arrLen, 0, dp);\n }\n};\n```\n\n\n```java []\nclass Solution {\n private static final int MOD = 1000000007;\n\n public int TopDown(int steps, int arrLen, int pos, int[][] dp) {\n if (steps == 0 && pos == 0) return 1;\n if (steps == 0 && pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n if (dp[steps][pos] != -1) return dp[steps][pos];\n return dp[steps][pos] = ((TopDown(steps - 1, arrLen, pos, dp) % MOD // stay\n + TopDown(steps - 1, arrLen, pos + 1, dp) % MOD) % MOD // right\n + TopDown(steps - 1, arrLen, pos - 1, dp) % MOD) % MOD; // left\n }\n\n public int numWays(int steps, int arrLen) {\n int[][] dp = new int[steps + 1][steps+2];\n for (int[] row : dp) Arrays.fill(row, -1);\n return TopDown(steps, arrLen, 0, dp);\n }\n}\n```\n\n\n```python []\nMOD = 10**9 + 7\n\nclass Solution:\n def TopDown(self, steps, arrLen, pos, dp):\n if steps == 0 and pos == 0:\n return 1\n if steps == 0 and pos != 0:\n return 0\n if steps < 0 or pos < 0 or pos >= arrLen:\n return 0\n if dp[steps][pos] != -1:\n return dp[steps][pos]\n dp[steps][pos] = ((self.TopDown(steps - 1, arrLen, pos, dp) % MOD # stay\n + self.TopDown(steps - 1, arrLen, pos + 1, dp) % MOD) % MOD # right\n + self.TopDown(steps - 1, arrLen\n\n, pos - 1, dp) % MOD) % MOD # left\n return dp[steps][pos]\n\n def numWays(self, steps, arrLen):\n dp = [[-1 for _ in range(steps + 2)] for _ in range(steps + 1)]\n return self.TopDown(steps, arrLen, 0, dp)\n```\n\n\n```javascript []\n\nvar MOD = 1000000007;\n\nvar TopDown = function (steps, arrLen, pos, dp) {\n if (steps === 0 && pos === 0) return 1;\n if (steps === 0 && pos !== 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n if (dp[steps][pos] !== -1) return dp[steps][pos];\n dp[steps][pos] =\n ((((TopDown(steps - 1, arrLen, pos, dp) % MOD) + // stay\n (TopDown(steps - 1, arrLen, pos + 1, dp) % MOD)) %\n MOD) + // right\n (TopDown(steps - 1, arrLen, pos - 1, dp) % MOD)) %\n MOD; // left\n return dp[steps][pos];\n};\n\nvar numWays = function (steps, arrLen) {\n const dp = Array.from({ length: steps + 1 }, () => Array(steps + 2).fill(-1));\n return TopDown(steps, arrLen, 0, dp);\n};\n\n\n```\n\n\n\n```csharp []\nppublic class Solution {\n private const int MOD = 1000000007;\n\n public int TopDown(int steps, int arrLen, int pos, int[][] dp) {\n if (steps == 0 && pos == 0) return 1;\n if (steps == 0 && pos != 0) return 0;\n if (steps < 0 || pos < 0 || pos >= arrLen) return 0;\n if (dp[steps][pos] != -1) return dp[steps][pos];\n dp[steps][pos] = ((TopDown(steps - 1, arrLen, pos, dp) % MOD // stay\n + TopDown(steps - 1, arrLen, pos + 1, dp) % MOD) % MOD // right\n + TopDown(steps - 1, arrLen, pos - 1, dp) % MOD) % MOD; // left\n return dp[steps][pos];\n }\n\n public int NumWays(int steps, int arrLen) {\n int[][] dp = new int[steps + 1][];\n for (int i = 0; i <= steps; i++) {\n dp[i] = new int[steps + 2]; \n for (int j = 0; j < steps + 2; j++) {\n dp[i][j] = -1;\n }\n }\n return TopDown(steps, arrLen, 0, dp);\n }\n}\n\n```\n\n---\n\n\n\n## Approach 3: Bottom-Up Dynamic Programming\n\n### Explanation\n\nThe problem asks us to find the number of ways to stay in the same place after some steps. We can solve this problem using dynamic programming.\n\nIn the dynamic programming approach, we maintain a 2D array `dp` where `dp[i][j]` represents the number of ways to be at position `j` after taking `i` steps. We initialize `dp[0][0]` to 1, as there is one way to be at position 0 after 0 steps.\n\nWe then iterate through the number of steps and positions, filling in the `dp` array according to the three possible movements: stay in the same place, move one step to the right, and move one step to the left. We use modular arithmetic with a constant `MOD` to prevent overflow.\n\nThe final answer is found in `dp[steps][0]`, which represents the number of ways to be at position 0 after taking `steps` steps.\n\n### Dry Run\n\nLet\'s dry run the code with `steps = 3` and `arrLen = 2`:\n\n1. Initialize the `dp` array:\n ```\n dp = [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]\n ```\n\n2. Fill in the `dp` array:\n - After 1 step, `dp[1][0] = dp[0][0] = 1`\n - After 1 step, `dp[1][1] = dp[0][0] + dp[0][1] = 1`\n - After 1 step, `dp[1][2] = dp[0][1] = 1`\n\n - After 2 steps, `dp[2][0] = dp[1][0] + dp[1][1] = 2`\n - After 2 steps, `dp[2][1] = dp[1][0] + dp[1][1] + dp[1][2] = 3`\n - After 2 steps, `dp[2][2] = dp[1][1] + dp[1][2] = 2`\n\n - After 3 steps, `dp[3][0] = dp[2][0] + dp[2][1] = 5`\n - After 3 steps, `dp[3][1] = dp[2][0] + dp[2][1] + dp[2][2] = 7`\n - After 3 steps, `dp[3][2] = dp[2][1] + dp[2][2] = 5`\n\n3. The final answer is `dp[3][0] = 5`, which is the number of ways to be at position 0 after taking 3 steps.\n\n### Edge Cases\n\n- When `steps` is 0, the number of ways to stay in the same place is 1.\n- When `arrLen` is 1, there is only one position, so the answer is 1 regardless of the number of steps.\n\n### Complexity Analysis\n\n- Time Complexity: O(steps * arrLen)\n- Space Complexity: O(steps * arrLen)\n\n\n# **Codes :**\n\n```cpp []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n static const int MOD = 1000000007;\n vector<vector<long long>> dp(steps + 1, vector<long long>(min(steps, arrLen) + 2, 0));\n dp[0][0] = 1;\n\n for (int step = 1; step <= steps; step++) {\n for (int pos = 0; pos < min(steps, arrLen); pos++) {\n dp[step][pos] = (((dp[step - 1][pos]) % MOD // stay\n + dp[step - 1][pos + 1] % MOD) % MOD // right\n + (pos > 0 ? dp[step - 1][pos - 1] : 0)) % MOD; // left\n }\n }\n return dp[steps][0];\n }\n};\n```\n\n```java []\npublic class Solution {\n private static final int MOD = 1000000007;\n\n public int numWays(int steps, int arrLen) {\n int[][] dp = new int[steps + 1][Math.min(steps, arrLen) + 2];\n dp[0][0] = 1;\n\n for (int step = 1; step <= steps; step++) {\n for (int pos = 0; pos < Math.min(steps, arrLen); pos++) {\n dp[step][pos] = (((dp[step - 1][pos] % MOD) // stay\n + (dp[step - 1][pos + 1] % MOD)) % MOD // right\n + ((pos > 0) ? (dp[step - 1][pos - 1] % MOD) : 0)) % MOD; // left\n }\n }\n return dp[steps][0];\n }\n}\n```\n\n\n\n```python []\nMOD = 10**9 + 7\n\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n dp = [[0] * (min(steps, arrLen) + 2) for _ in range(steps + 1)]\n dp[0][0] = 1\n\n for step in range(1, steps + 1):\n for pos in range(min(steps, arrLen)):\n dp[step][pos] = ((dp[step - 1][pos] + dp[step - 1][pos + 1]) % MOD + (dp[step - 1][pos - 1] if pos > 0 else 0)) % MOD\n\n return dp[steps][0]\n```\n\n\n```javascript []\nvar numWays = function (steps, arrLen) {\n const MOD = 10 ** 9 + 7;\n let dp = Array.from({ length: steps + 1 }, () => Array(Math.min(steps, arrLen) + 2).fill(0));\n dp[0][0] = 1;\n\n for (let step = 1; step <= steps; step++) {\n for (let pos = 0; pos < Math.min(steps, arrLen); pos++) {\n dp[step][pos] = ((dp[step - 1][pos] + dp[step - 1][pos + 1]) % MOD + (pos > 0 ? dp[step - 1][pos - 1] : 0)) % MOD;\n }\n }\n return dp[steps][0];\n};\n\n```\n\n```csharp []\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n const int MOD = 1000000007;\n long[][] dp = new long[steps + 1][];\n for (int i = 0; i <= steps; i++) {\n dp[i] = new long[Math.Min(steps, arrLen) + 2];\n for (int j = 0; j < Math.Min(steps, arrLen) + 2; j++) {\n dp[i][j] = 0;\n }\n }\n dp[0][0] = 1;\n\n for (int step = 1; step <= steps; step++) {\n for (int pos = 0; pos < Math.Min(steps, arrLen); pos++) {\n dp[step][pos] = ((dp[step - 1][pos] + dp[step - 1][pos + 1]) % MOD + (pos > 0 ? dp[step - 1][pos - 1] : 0)) % MOD;\n }\n }\n return (int)dp[steps][0];\n }\n}\n```\n---\n\n## Analysis of Code in Different Languages : \n\n\n\n\n\n| Language | Runtime (ms) | Memory (MB) |\n|------------|--------------|-------------|\n| C++ | 27 | 36 |\n| Java | 17 | 43.4 |\n| Python | 303 | 22 |\n| JavaScript | 55 | 48.3 |\n| C# | 27 | 36 |\n\n\n---\n# Consider UPVOTING\u2B06\uFE0F\n\n\n\n\n# DROP YOUR SUGGESTIONS IN THE COMMENT\n\n## Keep Coding\uD83E\uDDD1\u200D\uD83D\uDCBB\n\n -- *MR.ROBOT SIGNING OFF*\n\n\n | 3 | 0 | ['Array', 'Dynamic Programming', 'Recursion', 'Python', 'C++', 'Java', 'Python3', 'JavaScript', 'C#'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Updated with an O(steps^1.5) algorithm!!! -time and space optimized solution, 0ms beats 100% | updated-with-an-osteps15-algorithm-time-2g5n8 | Original Version #\nSaves half of the space comparing to the typical 2-arrays approach.\nSaves at most half of the time by skipping the unnecessary calculations | yjian012 | NORMAL | 2023-10-15T07:55:21.568297+00:00 | 2023-11-23T02:52:58.747979+00:00 | 67 | false | # Original Version #\nSaves half of the space comparing to the typical 2-arrays approach.\nSaves at most half of the time by skipping the unnecessary calculations.\nAlso optimized for the case `arrLen==2`.\n# Code\n```\n//https://hyper-meta.blogspot.com/\n#pragma GCC target("avx,mmx,sse2,sse3,sse4")\nauto _=[]()noexcept{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);return 0;}();\nunsigned int cnt[251];\nconst int mod=1000000007;\nclass Solution {\npublic:\n int numWays(int steps, int arrLen){\n if(arrLen<=2){\n if(arrLen==1) return 1;\n int p=(steps-1)/63,q=(steps-1)%63;\n unsigned long long r=(1ULL<<q)%mod,c=(1ULL<<63)%mod;\n while(p--) r=(r*c)%mod;\n return r;\n }\n int b=min(steps/2+1,arrLen),tmp2;\n unsigned long long tmp1;\n memset(cnt,0,b*sizeof(cnt[0]));\n cnt[0]=1;\n for(int i=0;i<steps;++i){\n tmp1=cnt[0];\n cnt[0]=(cnt[0]+cnt[1])%mod;\n int s=min(min(i+1,steps-i),b-1);\n for(int j=1;j<s;++j){tmp2=cnt[j]; cnt[j]=(tmp1+cnt[j]+cnt[j+1])%mod; tmp1=tmp2;}\n cnt[s]=(tmp1+cnt[s])%mod;\n }\n return cnt[0];\n }\n};\n```\n\nCan this be further optimized?\nMaybe.\nInspired by the matrix powering algorithom to find the Fibonacci numbers, this problem is quite similar. A side length `min(steps/2+1,arrLen)` matrix should do.\nIt should look like\n```\n1 1 0 0 0 ... 0\n1 1 1 0 0 ... 0\n0 1 1 1 0 ... 0\n0 0 1 1 1 ... 0\n...\n0 ... 0 1 1 1 0\n0 ... 0 0 1 1 1\n0 ... 0 0 0 1 1\n```\nwhich can be diagonalized as $M=PDP^{-1}$.\nThe result is the element of $M^s$ at `[0][0]`, which can be calculated as $P_{0i} D_{ii}^s P^{-1}_{i0}$. Considering the first row of $P$ and the first column of $P^{-1}$ should have a regular form, this should be an O(n) solution. I think it should work, but due to the scale of this problem, I\'m lacking motivation to try it out... anyway.\n\nEdit: OK I tried diagonalizing a 5*5 matrix, the result is more complicated than I thought. But still, if we can recognize the pattern, we should be able to generalize it easily...\nThe eigen values have known form, namely $a+2\\sqrt{bc}\\cos\\left(\\frac{k\\pi}{n+1}\\right), k=1...n$, in this case $1+2\\cos\\left(\\frac{k\\pi}{n+1}\\right)$. Now we just need to find the pattern for $P$...\n\n# Update 10/15: #\nI found the general form of the elements in the first row of $P$!\nThe formula is,\n$\\theta_i=\\frac{i\\pi}{n+1}, i=1,2,...n$\n$e_i=1+2\\cos\\theta_i$\n$p_i=\\sqrt{\\frac{2}{n+1}}\\sin\\theta_i$\n$ans=\\sum_ie_i^{s}p_i^2, s=steps$\n\nThe following code implements this algorithm. The only problem now is, the result could be very large, so how do we find the remainder of it `mod 1e9+7` accurately?\n```\n//https://hyper-meta.blogspot.com/\n#pragma GCC target("avx,mmx,sse2,sse3,sse4")\nauto _=[]()noexcept{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);return 0;}();\nunsigned int cnt[251];\nconst int mod=1000000007;\nclass Solution {\npublic:\n int numWays(int steps, int arrLen){\n if(arrLen<=2){\n if(arrLen==1) return 1;\n int p=(steps-1)/63,q=(steps-1)%63;\n unsigned long long c=(1ULL<<63)%mod,r=(1ULL<<q)%mod;\n while(p--) r=(r*c)%mod;\n return r;\n }\n int b=min(steps/2+1,arrLen),tmp2;\n\n //new algorithm\n double r=0.0;\n for(int i=1;i<=b;++i){\n double c=cos(M_PI*i/(b+1));\n r+=pow(1+2*c,steps)*(1-pow(c,2));\n }\n r=r*2/(b+1);\n if(r<(1ULL<<50)) return round(fmod(r,mod));\n\n //may not work due to rounding errors if result is too large, so back to old algorithm\n unsigned long long tmp1;\n memset(cnt,0,b*sizeof(cnt[0]));\n cnt[0]=1;\n for(int i=0;i<steps;++i){\n tmp1=cnt[0];\n cnt[0]=(cnt[0]+cnt[1])%mod;\n int s=min(min(i+1,steps-i),b-1);\n for(int j=1;j<s;++j){tmp2=cnt[j]; cnt[j]=(tmp1+cnt[j]+cnt[j+1])%mod; tmp1=tmp2;}\n cnt[s]=(tmp1+cnt[s])%mod;\n }\n return cnt[0];\n }\n};\n```\nSo it requires too much precision for very large outputs. But in general, it gives a very good approximation in $O(n)$ complexity. Amazing!\n\n# Update 10/18 #\nFollowing the path that the method above leads to, I discovered an $O(steps^{1.5})$ algorithm! It\'s a little too complicated, so I won\'t explain it here. The following is the code:\n```\n//https://hyper-meta.blogspot.com/\n#pragma GCC target("avx,mmx,sse2,sse3,sse4")\nauto _=[]()noexcept{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);return 0;}();\nunsigned int cnt[251];\nconst int mod=1000000007;\nvector<vector<int>> binom{{1}};\nvoid buildBinom(int n){\n for(int i=binom.size()-1;i<=n;++i){\n vector<int> v;\n v.reserve(i+2);\n v.emplace_back(1);\n const auto& b=binom.back();\n for(int j=0;j<i;++j) v.emplace_back((b[j]+b[j+1])%mod);\n v.emplace_back(1);\n binom.emplace_back(move(v));\n }\n}\nint getCoe(int s,int j,int t){\n if(j+t<0||s<2*j+t) return 0;\n return (long long)binom[s-j][j+t]*binom[s][j]%mod;\n}\nclass Solution {\npublic:\n int numWays(int steps, int arrLen){\n if(arrLen<=2){\n if(arrLen==1) return 1;\n int p=(steps-1)/63,q=(steps-1)%63;\n unsigned long long c=(1ULL<<63)%mod,r=(1ULL<<q)%mod;\n while(p--) r=(r*c)%mod;\n return r;\n }\n if(steps==1) return 1;\n if(arrLen>steps||arrLen*arrLen>steps){\n buildBinom(steps);\n long long t=0;\n int mm=steps/(2*arrLen+2);\n for(int mi=-mm;mi<=mm;++mi){\n int m=mi*(2*arrLen+2);\n int upper=(steps-m)/2+2;\n for(int j=0;j<=upper;++j){\n t=(t+2*getCoe(steps,j,m)-getCoe(steps,j,m+2)-getCoe(steps,j,m-2))%mod;\n }\n }\n return ((t*500000004)%mod+mod)%mod;\n }\n int tmp2;\n unsigned long long tmp1;\n memset(cnt,0,arrLen*sizeof(cnt[0]));\n cnt[0]=1;\n for(int i=0;i<steps;++i){\n tmp1=cnt[0];\n cnt[0]=(cnt[0]+cnt[1])%mod;\n for(int j=1;j<arrLen;++j){tmp2=cnt[j]; cnt[j]=(tmp1+cnt[j]+cnt[j+1])%mod; tmp1=tmp2;}\n cnt[arrLen]=(tmp1+cnt[arrLen])%mod;\n }\n return cnt[0];\n }\n};\n```\nBuilding the binomial table from scratch takes $O(steps^2)$, but it can be reused, so I don\'t include that in the complexity.\nIf $arrLen>\\sqrt{steps}$, the new algorithm takes $O(steps*steps/arrLen)\\leq O(steps^{1.5})$, on the other hand, if $arrLen\\leq\\sqrt{steps}$, the old algorithm takes $O(steps*arrLen)\\leq O(steps^{1.5})$.\nIt\'s especially helpful when $arrLen$ is large. When $arrLen\\geq steps/2+1$, the old algorithm has complexity $O(steps^2)$ while the new one has $O(steps)$.\nDetails can be found at: https://hyper-meta.blogspot.com/2023/10/the-long-journey-from-on2-to-on15.html | 3 | 0 | ['C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Python] Top Down DP - Clean & Concise | python-top-down-dp-clean-concise-by-hiep-x489 | \nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n @lru_cache(None)\n def dp(index, steps):\n if index < 0 or | hiepit | NORMAL | 2020-10-08T14:07:31.918309+00:00 | 2020-10-08T14:09:44.243793+00:00 | 232 | false | ```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n @lru_cache(None)\n def dp(index, steps):\n if index < 0 or index == arrLen: # index outside arraySize\n return 0\n \n if steps == 0:\n return 1 if index == 0 else 0\n \n ans = 0\n for i in range(-1, 2, 1): # try [left, stay, right]\n ans += dp(index+i, steps - 1)\n ans %= (10**9 + 7)\n return ans\n \n return dp(0, steps)\n```\n**Complexity**\n- Time & Space: `O(steps * min(steps, arrLen))` | 3 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java O(S* MIN(S, L)) Short RunTime Bottom-UP DP Beats 98% | java-os-mins-l-short-runtime-bottom-up-d-b8o5 | This is regular DP with some twists. The recurrence equation is easily derived by following logic:\n\nAt any index of ArrayLen one can move left, right or Stay | stack_underflow | NORMAL | 2019-12-14T22:08:19.208804+00:00 | 2019-12-14T22:12:01.334781+00:00 | 176 | false | This is regular DP with some twists. The recurrence equation is easily derived by following logic:\n\nAt any index of ArrayLen one can move left, right or Stay except at corners. Each of these 3 count as move. So `F(S, i) = F(S-1, i) + F(S-1, i-1) + F(S-1, i+1)` is recurrence for same logic which also takes care of corners as` i > 1` for `F(S-1, i-1)` (cannot move left at i = 0) and same logic for right most end. \n\nNow, if we think more the max number of right moves one can perform depends on array length and also moves because if array length is small no matter how many steps are allowed we are bounded to move right by array length. So DP array is bounded by `Math.min(arrLen, (steps/2) + 1)`. So is the logic in 2nd for loop. \n\nThe run time complexity is `O(S * MIN(S, L))` as in 2nd for loop we only loop for `Min(S/2, L)`\n\n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int MOD = (int)Math.pow(10, 9) + 7;\n if (steps == 0) return 0;\n int poss = Math.min(arrLen, (steps/2) + 1);\n int[][] dp = new int[steps+1][poss];\n dp[0][0] = 1;\n for (int s = 1; s <= steps; s++) {\n for (int i = Math.min(s, poss-1); i >= 0; i--) {\n dp[s][i] += ((((i > 0) ? dp[s-1][i-1] : 0) + dp[s-1][i]) % MOD + ((i < poss-1) ? dp[s-1][i+1] : 0)) % MOD;\n } \n }\n return dp[steps][0];\n }\n}\n``` | 3 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python3 Top-down DFS with Memoization | python3-top-down-dfs-with-memoization-by-7389 | \nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n import functools\n memo = {}\n M = 10 ** 9 + 7\n @functo | sakata_gintoki | NORMAL | 2019-11-25T18:40:41.011168+00:00 | 2019-11-25T18:40:41.011207+00:00 | 317 | false | ```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n import functools\n memo = {}\n M = 10 ** 9 + 7\n @functools.lru_cache(maxsize=None)\n def dfs(i,pos):\n if (i,pos) in memo: \n return memo[(i,pos)]\n if i == steps and pos == 0: #base end case that meet the requirement\n return 1\n if i == steps and pos != 0: #base end case that does not meet the requirement\n return 0 \n if 0 <= i <= steps and pos < 0 or pos >= arrLen: #case that does not meet the requirement during moving \n return 0\n res = 0\n res = (dfs(i + 1,pos) + dfs(i + 1, pos - 1) + dfs(i + 1, pos + 1)) % M #3 cases: stay, move left and move right\n memo[(i,pos)] = res \n return res\n return dfs(0,0)\n#I really appreciate it if u upvote \uFF08\uFFE3\uFE36\uFFE3\uFF09\u2197\n```\n | 3 | 0 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Solution + Explanation ✅ Beats 100% Runtime | solution-explanation-beats-100-runtime-b-ujai | Approach\nImagine standing at position $0$ on a line with a certain number of steps and available positions arrLen. \n> The goal is to find the count of ways to | ProbablyLost | NORMAL | 2023-12-27T10:29:49.974589+00:00 | 2023-12-27T10:29:49.974615+00:00 | 3 | false | # Approach\nImagine standing at position $0$ on a line with a certain number of `steps` and available positions `arrLen`. \n> The goal is to find the count of ways to return to position 0 after taking these steps.\n\nStarting at position 0 with 1 way after 0 steps, we consider movements `(stay, left, right)` at each step. By dynamically tracking ways to return to 0 within the steps, focusing on feasible positions, we iterate through steps and adjust possibilities at each position based on previous steps. The final count of ways to return to position 0 after all steps gives us the answer.\n\n# Code\n```\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\n let mod = 1_000_000_007\n let maxPosition = min(steps / 2, arrLen - 1)\n \n var dp = Array(repeating: 0, count: maxPosition + 1)\n dp[0] = 1 // Starting at position 0, we have one way.\n \n for _ in 1...steps {\n var nextDp = Array(repeating: 0, count: maxPosition + 1)\n \n for j in 0...maxPosition {\n nextDp[j] = dp[j]\n if j > 0 {\n nextDp[j] = (nextDp[j] + dp[j - 1]) % mod // Move one step left.\n }\n if j < maxPosition {\n nextDp[j] = (nextDp[j] + dp[j + 1]) % mod // Move one step right.\n }\n }\n \n dp = nextDp\n }\n \n return dp[0]\n }\n}\n\n``` | 2 | 0 | ['Dynamic Programming', 'Swift'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Grid DP🎯 | Top Down➡️Bottom Up | 😱Best Readable C++ Code😱 | 🔥Self Explanatory Comments🔥 | grid-dp-top-downbottom-up-best-readable-7bio5 | \uD83D\uDE0A ~ \uD835\uDE52\uD835\uDE5E\uD835\uDE69\uD835\uDE5D \u2764\uFE0F \uD835\uDE57\uD835\uDE6E \uD835\uDE43\uD835\uDE5E\uD835\uDE67\uD835\uDE5A\uD835\uDE | hirenjoshi | NORMAL | 2023-10-16T09:05:36.105626+00:00 | 2024-08-05T19:47:52.449419+00:00 | 17 | false | \uD83D\uDE0A ~ \uD835\uDE52\uD835\uDE5E\uD835\uDE69\uD835\uDE5D \u2764\uFE0F \uD835\uDE57\uD835\uDE6E \uD835\uDE43\uD835\uDE5E\uD835\uDE67\uD835\uDE5A\uD835\uDE63\n\n# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n***Hi There Its Easy! Take A Look At The Code And Comments Within It You\'ll Get It.\nIf You\'ve Any Kind Of Doubt! Feel Free To Comment, I\'ll Definitely Reply!***\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n***Both Approach :-\n: Using Top Down (Recursion To Memoization)\n: Using Bottom Up (2D + 1D Tabulation)***\n\n# Complexity\n- ***Time complexity: Mentioned with the code***\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- ***Space complexity: Mentioned with the code***\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n**Approach 1 : Using Top Down (Recursion To Memoization)**\n```\n// Class to implement the Top-down approach:\nclass TopDown { \n #define MOD 1000000007\n\npublic:\n // Method to find the total number of ways, using recursion with memoization - O(steps * min(arrLen, steps)) & O(steps * min(arrLen, steps))\n int numWays(int steps, int arrLen) {\n arrLen = min(arrLen, steps);\n vector<vector<int>> memory(steps + 1, vector<int>(arrLen, -1));\n return solveWithMemo(memory, steps, arrLen, 0);\n }\n\nprivate:\n // O(3 * steps * min(arrLen, steps)) & O(steps * min(arrLen, steps) + steps)\n int solveWithMemo(vector<vector<int>>& memory, int steps, int arrLen, int pointer) {\n // Edge case: If the pointer is still at index 0 after exactly "steps" steps then you\'ve one valid way\n if(steps == 0)\n return (pointer == 0);\n\n // Edge case: If the steps becomes negative or the pointer is placed outside of the array at any time then you\'ve no valid way\n if(pointer < 0 || pointer == arrLen)\n return 0;\n\n // Memoization memory: If the current state is already computed then return the computed value\n if(memory[steps][pointer] != -1)\n return memory[steps][pointer];\n\n // There are always three posibilities to perform at each step\n int moveToLeft = solveWithMemo(memory, steps - 1, arrLen, pointer - 1); // Is to move 1 position to the left \n int moveToRight = solveWithMemo(memory, steps - 1, arrLen, pointer + 1); // Is to move 1 position to the right \n int stayAtSame = solveWithMemo(memory, steps - 1, arrLen, pointer); // Is to stay at the same place \n\n // Store the result value to the memoization memory and then return it\n return memory[steps][pointer] = ((moveToLeft + moveToRight) % MOD + stayAtSame) % MOD;\n }\n \n // O(3^steps) & O(steps)\n int solveWithoutMemo(int steps, int arrLen, int pointer) {\n // Edge case: If the pointer is still at index 0 after exactly "steps" steps then you\'ve one valid way\n if(steps == 0)\n return (pointer == 0);\n\n // Edge case: If the steps becomes negative or the pointer is placed outside of the array at any time then you\'ve no valid way\n if(pointer < 0 || pointer == arrLen)\n return 0;\n\n // There are always three posibilities to perform at each step\n int moveToLeft = solveWithoutMemo(steps - 1, arrLen, pointer - 1); // Is to move 1 position to the left \n int moveToRight = solveWithoutMemo(steps - 1, arrLen, pointer + 1); // Is to move 1 position to the right\n int stayAtSame = solveWithoutMemo(steps - 1, arrLen, pointer); // Is to stay at the same place \n\n // Return the result value\n return ((moveToLeft + moveToRight) % MOD + stayAtSame) % MOD;\n }\n};\n```\n**Approach 2 : Using Bottom Up (2D + 1D Tabulation)**\n```\n// Class to implement the Bottom-up approach:\nclass BottomUp {\n #define MOD 1000000007\n\npublic:\n // #1 Method to find the total number of ways, using 2D tabulation - O(steps * min(arrLen, steps)) & O(steps * min(arrLen, steps))\n int numWays_V1(int steps, int arrLen) {\n // Pointer movements are dependent on both steps and the array length hence it\'s better to choose the minimum one to fit in the memory \n arrLen = min(arrLen, steps);\n\n // 2D DP table\n vector<vector<int>> dp(steps + 1, vector<int>(arrLen + 2, 0));\n\n // Initialize the first edge case: If the pointer is still at index 0 after exactly "steps" steps then you\'ve one valid way\n dp[0][1] = 1;\n\n // Fill the rest of the table\n for(int index = 1; index <= steps; ++index) { \n for(int pointer = 1; pointer <= arrLen; ++pointer) {\n int moveToLeft = dp[index - 1][pointer - 1]; \n int moveToRight = dp[index - 1][pointer + 1]; \n int stayAtSame = dp[index - 1][pointer]; \n dp[index][pointer] = ((moveToLeft + moveToRight) % MOD + stayAtSame) % MOD; \n }\n }\n\n // Return the result value\n return dp[steps][1];\n }\n\n // #2 Method to find the total number of ways, using 1D tabulation - O(steps * min(arrLen, steps)) & O(min(arrLen, steps))\n int numWays_V2(int steps, int arrLen) {\n // Pointer movements are dependent on both steps and the array length hence it\'s better to choose the minimum one to fit in the memory \n arrLen = min(arrLen, steps);\n\n // 1D DP tables\n vector<int> prevRow(arrLen + 2, 0), currRow(arrLen + 2, 0);\n\n // Initialize the first edge case: If the pointer is still at index 0 after exactly "steps" steps then you\'ve one valid way\n prevRow[1] = 1;\n\n // Fill the rest of the table\n for(int index = 1; index <= steps; ++index) {\n for(int pointer = 1; pointer <= arrLen; ++pointer) {\n int moveToLeft = prevRow[pointer - 1]; \n int moveToRight = prevRow[pointer + 1]; \n int stayAtSame = prevRow[pointer]; \n currRow[pointer] = ((moveToLeft + moveToRight) % MOD + stayAtSame) % MOD; \n }\n prevRow = currRow;\n }\n\n // Return the result value\n return prevRow[1];\n }\n};\n```\n\uD835\uDDE8\uD835\uDDE3\uD835\uDDE9\uD835\uDDE2\uD835\uDDE7\uD835\uDDD8 \uD835\uDDDC\uD835\uDDD9 \uD835\uDDEC\uD835\uDDE2\uD835\uDDE8 \uD835\uDDDF\uD835\uDDDC\uD835\uDDDE\uD835\uDDD8 \uD835\uDDE7\uD835\uDDDB\uD835\uDDD8 \uD835\uDDE6\uD835\uDDE2\uD835\uDDDF\uD835\uDDE8\uD835\uDDE7\uD835\uDDDC\uD835\uDDE2\uD835\uDDE1 \uD83D\uDC4D | 2 | 0 | ['Dynamic Programming', 'Matrix', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅☑[C++/C/Java/Python/JavaScript] || 3 Approaches || EXPLAINED🔥 | ccjavapythonjavascript-3-approaches-expl-b6sa | PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n(Also explained in the code)\n\n#### Approach 1(Top Down DP)\n\n1. Class Definition: The code defines a cla | MarkSPhilip31 | NORMAL | 2023-10-15T19:09:36.810594+00:00 | 2023-10-15T19:09:36.810614+00:00 | 59 | false | # PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n**(Also explained in the code)**\n\n#### *Approach 1(Top Down DP)*\n\n1. **Class Definition:** The code defines a class called Solution.\n\n1. **Member Variables:**\n\n - **memo:** A 2D vector to store the memoization table for dynamic programming.\n - **MOD:** A constant for the modulo operation.\n - **arrLen:** A variable to store the minimum of `arrLen` and `steps`.\n1. **dp Function:**\n\n - This is a recursive function that calculates the number of ways to reach a certain state (index and remaining steps).\n - It takes two arguments: `curr` (current index) and `remain` (remaining steps).\n - **Base case:**\n - If there are no remaining steps (`remain == 0`), it checks if the current index is at position 0 (`curr == 0`). If true, it returns 1 (indicating a valid way); otherwise, it returns 0.\n - **Memoization:**\n - It checks if the result for the current state ( ) is already stored in the `memo` table. If found, it returns the memoized result.\n - **Recursive Computation:**\n - It computes the result by recursively calling `dp` for three possible scenarios:\n - Moving to the same position (`dp(curr, remain - 1)`).\n - Moving one step to the left (`dp(curr - 1, remain - 1)`), if it\'s a valid move (checking if `curr > 0`).\n - Moving one step to the right (`dp(curr + 1, remain - 1)`), if it\'s a valid move (checking if `curr < arrLen - 1`).\n - It calculates the sum of these scenarios while considering the modulo operation with `MOD`.\n - Finally, it stores the computed result in the `memo` table and returns it.\n1. **numWays Function:**\n\n - This function is the entry point for calculating the number of ways.\n - It takes two arguments: `steps` (total steps allowed) and `arrLen` (the length of the array).\n - It first sets `arrLen` to the minimum of `arrLen` and `steps`.\n - It initializes the `memo` table as a 2D vector with dimensions `[arrLen][steps + 1]`, filled with `-1` to indicate that no values have been computed yet.\n - It calls the `dp` function with initial arguments (`0, steps`) to start the recursive computation.\n - The result is the number of ways to reach the index 0 within `steps` steps.\n\n\n# Complexity\n- *Time complexity:*\n $$O(n\u22C5min(n,m))$$\n \n\n- *Space complexity:*\n $$O(n\u22C5min(n,m))$$\n \n\n\n# Code\n```C++ []\n\nclass Solution {\npublic:\n vector<vector<int>> memo;\n int MOD = 1e9 + 7;\n int arrLen;\n \n int dp(int curr, int remain) {\n if (remain == 0) {\n if (curr == 0) {\n return 1;\n }\n \n return 0;\n }\n \n if (memo[curr][remain] != -1) {\n return memo[curr][remain];\n }\n\n int ans = dp(curr, remain - 1);\n if (curr > 0) {\n ans = (ans + dp(curr - 1, remain - 1)) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp(curr + 1, remain - 1)) % MOD;\n }\n \n memo[curr][remain] = ans;\n return ans;\n }\n \n int numWays(int steps, int arrLen) {\n arrLen = min(arrLen, steps);\n this->arrLen = arrLen;\n memo = vector(arrLen, vector(steps + 1, -1));\n return dp(0, steps);\n }\n};\n\n```\n\n\n```C []\n#include <stdio.h>\n#include <stdlib.h>\n\nint MOD = 1000000007;\n\nint **memo;\nint arrLen;\n\nint dp(int curr, int remain) {\n if (remain == 0) {\n if (curr == 0) {\n return 1;\n }\n return 0;\n }\n\n if (memo[curr][remain] != -1) {\n return memo[curr][remain];\n }\n\n int ans = dp(curr, remain - 1);\n if (curr > 0) {\n ans = (ans + dp(curr - 1, remain - 1)) % MOD;\n }\n\n if (curr < arrLen - 1) {\n ans = (ans + dp(curr + 1, remain - 1)) % MOD;\n }\n\n memo[curr][remain] = ans;\n return ans;\n}\n\nint numWays(int steps, int arrLen) {\n arrLen = arrLen < steps ? arrLen : steps;\n memo = (int **)malloc(arrLen * sizeof(int *));\n for (int i = 0; i < arrLen; i++) {\n memo[i] = (int *)malloc((steps + 1) * sizeof(int));\n for (int j = 0; j <= steps; j++) {\n memo[i][j] = -1;\n }\n }\n\n int result = dp(0, steps);\n\n // Clean up memory\n for (int i = 0; i < arrLen; i++) {\n free(memo[i]);\n }\n free(memo);\n\n return result;\n}\n\n\n\n```\n\n```Java []\nclass Solution {\n int[][] memo;\n int MOD = (int) 1e9 + 7;\n int arrLen;\n \n public int dp(int curr, int remain) {\n if (remain == 0) {\n if (curr == 0) {\n return 1;\n }\n \n return 0;\n }\n \n if (memo[curr][remain] != -1) {\n return memo[curr][remain];\n }\n\n int ans = dp(curr, remain - 1);\n if (curr > 0) {\n ans = (ans + dp(curr - 1, remain - 1)) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp(curr + 1, remain - 1)) % MOD;\n }\n \n memo[curr][remain] = ans;\n return ans;\n }\n \n public int numWays(int steps, int arrLen) {\n arrLen = Math.min(arrLen, steps);\n this.arrLen = arrLen;\n memo = new int[arrLen][steps + 1];\n for (int[] row : memo) {\n Arrays.fill(row, -1);\n }\n \n return dp(0, steps);\n }\n}\n\n```\n\n```python3 []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n @cache\n def dp(curr, remain):\n if remain == 0:\n if curr == 0:\n return 1\n \n return 0\n \n ans = dp(curr, remain - 1)\n if curr > 0:\n ans = (ans + dp(curr - 1, remain - 1)) % MOD\n \n if curr < arrLen - 1:\n ans = (ans + dp(curr + 1, remain - 1)) % MOD\n \n return ans\n \n MOD = 10 ** 9 + 7\n return dp(0, steps)\n\n```\n\n\n```javascript []\n\n```\n\n\n---\n\n#### *Approach 2(Bottom Up DP)*\n\n1. **numWays Function:**\n\n - This function calculates the number of ways to reach index 0 in an array with a given number of steps while following specific rules.\n1. **Variables:**\n\n - **MOD:** A constant for the modulo operation.\n - **arrLen:** It\'s set to the minimum of arrLen and steps.\n - **dp:** A 2D vector to store dynamic programming results.\n1. **Initialization:**\n\n - The code initializes `dp` as a 2D vector of dimensions `[arrLen][steps + 1]` and initializes all values to 0, except for `dp[0][0]`, which is set to 1 (starting point).\n1. **Dynamic Programming Loop:**\n\n - The function uses a nested loop to compute the dynamic programming results.\n - The outer loop iterates from `remain = 1` to `steps`, representing the remaining steps.\n - The inner loop iterates in reverse order from `curr = arrLen - 1` down to `0`, representing the current position.\n1. **Calculating ans:**\n\n - `ans` is a variable to store the number of ways to reach the current position (`curr`) with the given number of remaining steps (`remain`).\n - Initially, it\'s set to the value from the previous step `dp[curr][remain - 1]`.\n1. **Checking Valid Moves:**\n\n - It checks two possible moves:\n - Moving one step to the left if `curr > 0`, and adds `dp[curr - 1][remain - 1]` to ans.\n - Moving one step to the right if `curr < arrLen - 1`, and adds `dp[curr + 1][remain - 1]` to `ans`.\n1. **Modulo Operation:**\n\n - After updating `ans`, it applies the modulo operation with `MOD` to prevent integer overflow.\n1. **Updating dp Table:**\n\n- The calculated `ans` is stored in the `dp` table for the current position `curr` and remaining steps `remain`.\n1. **Return Result:**\n\nThe final result is the number of ways to reach index 0 `(dp[0][steps])`.\n\n\n# Complexity\n- *Time complexity:*\n $$O(n\u22C5min(n,m))$$\n \n\n- *Space complexity:*\n $$O(n\u22C5min(n,m))$$\n \n\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int MOD = 1e9 + 7;\n arrLen = min(arrLen, steps);\n vector<vector<int>> dp(arrLen, vector(steps + 1, 0));\n dp[0][0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = dp[curr][remain - 1];\n \n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % MOD;\n }\n \n dp[curr][remain] = ans;\n }\n }\n \n return dp[0][steps];\n }\n};\n```\n\n\n```C []\n\n#include <stdio.h>\n#include <stdlib.h>\n\nint min(int a, int b) {\n return (a < b) ? a : b;\n}\n\nint numWays(int steps, int arrLen) {\n int MOD = 1000000007;\n arrLen = min(arrLen, steps);\n int dp[arrLen][steps + 1];\n \n for (int i = 0; i < arrLen; i++) {\n for (int j = 0; j <= steps; j++) {\n dp[i][j] = 0;\n }\n }\n \n dp[0][0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = dp[curr][remain - 1];\n \n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % MOD;\n }\n \n dp[curr][remain] = ans;\n }\n }\n \n return dp[0][steps];\n}\n\nint main() {\n int steps = 3;\n int arrLen = 2;\n int result = numWays(steps, arrLen);\n printf("Number of ways: %d\\n", result);\n return 0;\n}\n\n\n```\n\n```Java []\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int MOD = (int) 1e9 + 7;\n arrLen = Math.min(arrLen, steps);\n int[][] dp = new int[arrLen][steps + 1];\n dp[0][0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = dp[curr][remain - 1];\n \n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % MOD;\n }\n \n dp[curr][remain] = ans;\n }\n }\n \n return dp[0][steps];\n }\n}\n\n```\n\n```python3 []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n MOD = 10 ** 9 + 7\n arrLen = min(arrLen, steps)\n dp = [[0] * (steps + 1) for _ in range(arrLen)]\n dp[0][0] = 1\n \n for remain in range(1, steps + 1):\n for curr in range(arrLen - 1, -1, -1):\n ans = dp[curr][remain - 1]\n \n if curr > 0:\n ans = (ans + dp[curr - 1][remain - 1]) % MOD\n \n if curr < arrLen - 1:\n ans = (ans + dp[curr + 1][remain - 1]) % MOD\n \n dp[curr][remain] = ans\n \n return dp[0][steps]\n```\n\n\n```javascript []\nfunction numWays(steps, arrLen) {\n const MOD = 1000000007;\n arrLen = Math.min(arrLen, steps);\n const dp = new Array(arrLen).fill(0).map(() => new Array(steps + 1).fill(0));\n \n dp[0][0] = 1;\n \n for (let remain = 1; remain <= steps; remain++) {\n for (let curr = arrLen - 1; curr >= 0; curr--) {\n let ans = dp[curr][remain - 1];\n \n if (curr > 0) {\n ans = (ans + dp[curr - 1][remain - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + dp[curr + 1][remain - 1]) % MOD;\n }\n \n dp[curr][remain] = ans;\n }\n }\n \n return dp[0][steps];\n}\n\nconst steps = 3;\nconst arrLen = 2;\nconst result = numWays(steps, arrLen);\nconsole.log("Number of ways:", result);\n\n```\n\n\n---\n#### *Approach 3(Space Optimized DP)*\n\n1. The function `numWays` takes two parameters: `steps`, which represents the total number of steps allowed, and `arrLen`, which is the length of the array.\n\n1. It defines the constant `MOD` to be 1e9 + 7, which is used to perform modulo operations to prevent integer overflow.\n\n1. To ensure that `arrLen` does not exceed the number of steps available, it sets `arrLen` to the minimum of `arrLen` and `steps`.\n\n1. It initializes two vectors, `dp` and `prevDp`, both of size `arrLen`, to keep track of dynamic programming values.\n\n1. The `prevDp` vector is initialized with a single element set to 1. This represents the starting point where there\'s only one way to reach index 0 (no steps taken).\n\n1. It enters a loop that iterates through the number of remaining steps, from 1 up to `steps`.\n\n1. Inside the loop, it reinitializes the `dp` vector to all 0s. This vector represents the dynamic programming values for the current number of remaining steps.\n\n1. It then enters a nested loop that iterates through each possible index `curr` in the range from `arrLen - 1` down to 0. This represents considering the array length and the possible positions at each step.\n\n1. For each `curr`, it calculates the number of ways to reach that position in the current step (`remain`). It uses the dynamic programming values from the previous step (`prevDp`) to calculate this. The calculation takes into account the possibilities of staying in the same position or moving one step left or right if those positions are within bounds.\n\n1. The computed value is stored in the `dp[curr]` vector for the current step.\n\n1. After completing the inner loop, the `prevDp` vector is updated with the values from the `dp` vector. This is done to prepare for the next iteration of the loop.\n\n1. Once the loop finishes, the final result is in the `dp[0]` element of the vector, which represents the number of ways to reach index 0 within the given number of steps.\n\n1. The function returns this value as the answer.\n\n# Complexity\n- *Time complexity:*\n $$O(n\u22C5min(n,m))$$\n \n\n- *Space complexity:*\n $$O(min(n,m))$$\n \n\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int MOD = 1e9 + 7;\n arrLen = min(arrLen, steps);\n vector<int> dp(arrLen, 0);\n vector<int> prevDp(arrLen, 0);\n prevDp[0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n dp = vector(arrLen, 0);\n \n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = prevDp[curr];\n \n if (curr > 0) {\n ans = (ans + prevDp[curr - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + prevDp[curr + 1]) % MOD;\n }\n \n dp[curr] = ans;\n }\n \n prevDp = dp;\n }\n \n return dp[0];\n }\n};\n```\n\n\n```C []\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n\nint numWays(int steps, int arrLen) {\n int MOD = 1000000007;\n arrLen = arrLen < steps ? arrLen : steps;\n \n int* dp = (int*)malloc(arrLen * sizeof(int));\n int* prevDp = (int*)malloc(arrLen * sizeof(int));\n \n for (int i = 0; i < arrLen; i++) {\n dp[i] = 0;\n prevDp[i] = 0;\n }\n \n prevDp[0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = prevDp[curr];\n \n if (curr > 0) {\n ans = (ans + prevDp[curr - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + prevDp[curr + 1]) % MOD;\n }\n \n dp[curr] = ans;\n }\n \n // Swap dp and prevDp arrays for the next iteration\n int* temp = dp;\n dp = prevDp;\n prevDp = temp;\n }\n \n int result = dp[0];\n \n free(dp);\n free(prevDp);\n \n return result;\n}\n\nint main() {\n int steps = 3;\n int arrLen = 2;\n \n int ways = numWays(steps, arrLen);\n \n printf("Number of Ways: %d\\n", ways);\n \n return 0;\n}\n\n\n```\n\n```Java []\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int MOD = (int) 1e9 + 7;\n arrLen = Math.min(arrLen, steps);\n int[] dp = new int[arrLen];\n int[] prevDp = new int[arrLen];\n prevDp[0] = 1;\n \n for (int remain = 1; remain <= steps; remain++) {\n dp = new int[arrLen];\n \n for (int curr = arrLen - 1; curr >= 0; curr--) {\n int ans = prevDp[curr];\n if (curr > 0) {\n ans = (ans + prevDp[curr - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + prevDp[curr + 1]) % MOD;\n }\n \n dp[curr] = ans;\n }\n \n prevDp = dp;\n }\n \n return dp[0];\n }\n}\n\n```\n\n```python3 []\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n MOD = 10 ** 9 + 7\n arrLen = min(arrLen, steps)\n dp = [0] * (arrLen)\n prevDp = [0] * (arrLen)\n prevDp[0] = 1\n \n for remain in range(1, steps + 1):\n dp = [0] * (arrLen)\n \n for curr in range(arrLen - 1, -1, -1):\n ans = prevDp[curr]\n \n if curr > 0:\n ans = (ans + prevDp[curr - 1]) % MOD\n \n if curr < arrLen - 1:\n ans = (ans + prevDp[curr + 1]) % MOD\n \n dp[curr] = ans\n \n prevDp = dp\n \n return dp[0]\n```\n\n\n```javascript []\nfunction numWays(steps, arrLen) {\n const MOD = 1000000007;\n arrLen = Math.min(arrLen, steps);\n \n let dp = new Array(arrLen).fill(0);\n let prevDp = new Array(arrLen).fill(0);\n \n prevDp[0] = 1;\n \n for (let remain = 1; remain <= steps; remain++) {\n for (let curr = arrLen - 1; curr >= 0; curr--) {\n let ans = prevDp[curr];\n \n if (curr > 0) {\n ans = (ans + prevDp[curr - 1]) % MOD;\n }\n \n if (curr < arrLen - 1) {\n ans = (ans + prevDp[curr + 1]) % MOD;\n }\n \n dp[curr] = ans;\n }\n \n // Swap dp and prevDp arrays for the next iteration\n [dp, prevDp] = [prevDp, dp];\n }\n \n return dp[0];\n}\n\nconst steps = 3;\nconst arrLen = 2;\n\nconst ways = numWays(steps, arrLen);\nconsole.log("Number of Ways: " + ways);\n\n```\n\n\n---\n\n# PLEASE UPVOTE IF IT HELPED\n\n---\n---\n\n\n--- | 2 | 0 | ['Dynamic Programming', 'C', 'C++', 'Java', 'Python3', 'JavaScript'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Dynamic Programming Solution using Swift | dynamic-programming-solution-using-swift-2r5y | Intuition\nTo solve this problem, we need to consider the possibilities of moving left, right, or staying in the same position at each step. Dynamic programming | tywysocki | NORMAL | 2023-10-15T18:44:35.190514+00:00 | 2023-10-15T18:44:35.190552+00:00 | 27 | false | # Intuition\nTo solve this problem, we need to consider the possibilities of moving left, right, or staying in the same position at each step. Dynamic programming is a suitable approach to keep track of the number of ways to reach each position after each step.\n\n# Approach\nWe create a 2D array dp to store the number of ways to reach each position in the array after each step. We iterate through each step and each position, updating dp based on the three possibilities mentioned earlier. Finally, we return the number of ways to reach position 0 after exactly \'steps\' steps.\n\n# Complexity\n- **Time complexity**:\n\n$O(steps * min(steps / 2, arrLen - 1))$\n\n- **Space complexity**:\n\n$O(steps * min(steps / 2, arrLen - 1))$\n\n# Code\n```\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\n let mod = 1_000_000_007\n let maxPosition = min(steps / 2, arrLen - 1)\n \n // Create a 2D array to store the number of ways to reach each position in the array after each step.\n var dp = Array(repeating: Array(repeating: 0, count: maxPosition + 1), count: steps + 1)\n \n dp[0][0] = 1 // Starting at position 0, we have one way.\n \n // Fill in the dp array.\n for i in 1...steps {\n for j in 0...maxPosition {\n dp[i][j] = dp[i][j] % mod // Reset the value at the current position.\n dp[i][j] = (dp[i][j] + dp[i - 1][j]) % mod // Stay in the same position.\n if j > 0 {\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod // Move one step left.\n }\n if j < maxPosition {\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod // Move one step right.\n }\n }\n }\n \n return dp[steps][0]\n }\n}\n\n``` | 2 | 0 | ['Dynamic Programming', 'Swift'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | By-using-Tabulation | by-using-tabulation-by-mg45-ievq | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | MG45 | NORMAL | 2023-10-15T07:45:41.975874+00:00 | 2023-10-15T07:50:25.126994+00:00 | 55 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(steps*(max(arrLen,steps)))\n\n\n- Space complexity:O(steps+arrLen)\n\n\n# Code\n```\nclass Solution {\npublic:\n // int solve(int steps,int arrlen,int cnt,int st,vector<vector<int>>dp)\n // {\n // if(st>arrlen||st<1||cnt>steps)\n // return 0;\n\n // if(cnt==steps&&st==1)\n // return 1;\n // if(dp[cnt][st]!=-1)\n // return dp[cnt][st];\n\n // int ans=0;\n // ans+=(solve(steps,arrlen,cnt+1,st-1,dp)+solve(steps,arrlen,cnt+1,st,dp)+solve(steps,arrlen,cnt+1,st+1,dp))%1000000007;\n\n // return dp[cnt][st]=ans;\n // }\n int numWays(int steps, int arrLen) {\n const int MOD = 1000000007;\n arrLen = min(steps, arrLen);\n vector<vector<int>> dp(steps + 1, vector<int>(arrLen + 1, 0));\n\n dp[0][1] = 1; \n\n for (int i = 1; i <= steps; ++i) {\n for (int j = 1; j <= arrLen; ++j) {\n //Same Position\n dp[i][j] = (dp[i][j] + dp[i - 1][j]) % MOD; \n //left side move\n if (j > 1)\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % MOD; \n //right Side move\n if (j < arrLen)\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % MOD; \n }\n }\n\n return dp[steps][1];\n}\n\n};\n``` | 2 | 0 | ['C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Well explained || Noob solution || DP || Easiest solution | well-explained-noob-solution-dp-easiest-40a8l | Intuition\nEverytime , we have to explore three cases .\n\n# Approach\nInitially , I did it recursively then memoized it .\nEverytime, we will explore the three | _chintu_bhai | NORMAL | 2023-10-15T06:21:30.854285+00:00 | 2023-10-15T06:21:30.854308+00:00 | 96 | false | # Intuition\nEverytime , we have to explore three cases .\n\n# Approach\nInitially , I did it recursively then memoized it .\nEverytime, we will explore the three cases. Everytime our position and steps will get change. \nStarting with starting point and with 0 steps will be exploring all the three cases and will make the changes to corresponding parameters.\n\nhelper(i,j,steps,arrlen,dp)\ni-->pos\nj-->made steps\nsteps-->max steps\n**maxwego-->max we can go such that we would be ableto return back to starting point.**\nmaxwego=min((steps/2)+1,arrLen);\n\nand recursively call the function for left,right and stay . Also, we need to make sure that the pointer should not point outside of our array.Calculated all the possiblity .\n\nAfter having tle , I further memoized it and got accepted.\n# Complexity\n- Time complexity:\nO(N^2)\n\n- Space complexity:\nO(N^2)\n\n# Code\n```\nclass Solution {\npublic:\nlong long int mod=1e9+7;\n int helper(int i,int j,int steps,int maxwego, vector<vector<int>>&dp)\n {\n // we will check whether after making all the steps , we are at starting point or not\n if(j==steps)\n {\n if(i==0)// if yes , we will return 1\n {\n return 1;\n }\n return 0;//else 0\n }\n if(dp[i][j]!=-1)\n {\n return dp[i][j];\n }\n long long int left=0,right=0,stay=0;\n if(i>0)\n left=helper(i-1,j+1,steps,maxwego,dp);\n if(i<maxwego-1)\n right=helper(i+1,j+1,steps,maxwego,dp);\n stay=helper(i,j+1,steps,maxwego,dp);\n return dp[i][j]=((left+right)%mod+stay)%(mod);\n }\n int numWays(int steps, int arrLen) {\n int x=min((steps/2)+1,arrLen);//the maximum we can go \n vector<vector<int>>dp(x,vector<int>(steps+1,-1));\n return helper(0,0,steps,x,dp);\n }\n};\n\n```\n**If you found this helpful , please consider it for upvoting.** | 2 | 0 | ['C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C# Solution for Number of Ways to Stay in the Same Place After Some Steps Problem | c-solution-for-number-of-ways-to-stay-in-w54g | Intuition\n Describe your first thoughts on how to solve this problem. \nThe problem requires finding the number of ways to reach index 0 after a certain number | Aman_Raj_Sinha | NORMAL | 2023-10-15T06:20:05.222841+00:00 | 2023-10-15T06:20:05.222858+00:00 | 36 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem requires finding the number of ways to reach index 0 after a certain number of steps, considering movement to the left, right, or staying in the same place within the given array.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nThe solution employs dynamic programming to calculate the number of ways for each step and position in the array. We use a 2D array dp[steps + 1][min(steps, arrLen)] to store the number of ways to reach each position after a certain number of steps.\n\n1.\tInitialize the base case: there is only one way to stay at index 0 with 0 steps.\n2.\tIterate through each step, calculating the number of ways to reach each position by considering movement to the left, right, or staying in the same place.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nThe time complexity is O(steps * arrLen), where steps is the number of steps and arrLen is the length of the array. In the worst case, we iterate through each step and each position in the array, performing constant time operations.\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nThe space complexity is O(steps * min(steps, arrLen)), where steps is the number of steps and arrLen is the length of the array. We use a 2D array to store the number of ways for each step and position, resulting in the given space complexity.\n\n# Code\n```\npublic class Solution {\n public int NumWays(int steps, int arrLen) {\n int mod = 1000000007;\n int maxPos = Math.Min(steps, arrLen);\n \n // Initialize a 2D array to store the number of ways to reach index 0\n int[][] dp = new int[steps + 1][];\n for (int i = 0; i <= steps; i++) {\n dp[i] = new int[maxPos];\n }\n \n dp[0][0] = 1; // Base case: 1 way to stay at index 0 with 0 steps\n \n // Iterate through each step\n for (int i = 1; i <= steps; i++) {\n for (int j = 0; j < maxPos; j++) {\n dp[i][j] = dp[i - 1][j]; // Stay in the same place\n \n if (j > 0)\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod; // Move one step left\n \n if (j < maxPos - 1)\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod; // Move one step right\n }\n }\n \n return dp[steps][0];\n }\n}\n``` | 2 | 0 | ['C#'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++ || Recursion --> memoization | c-recursion-memoization-by-amol_2004-c4vl | Intuition\n- i cannot exceed to steps/2\n\n# Code\n\nclass Solution {\nprivate:\n long long solve(int steps,int arrLen, int i, vector<vector<long long>> &dp) | amol_2004 | NORMAL | 2023-10-15T05:08:26.311520+00:00 | 2023-10-15T05:08:26.311545+00:00 | 141 | false | # Intuition\n- `i` cannot exceed to `steps/2`\n\n# Code\n```\nclass Solution {\nprivate:\n long long solve(int steps,int arrLen, int i, vector<vector<long long>> &dp){\n if(!i && !steps)\n return 1;\n if(i == arrLen || steps < 0 || i < 0 || i > steps)\n return 0;\n if(dp[steps][i] != -1)\n return dp[steps][i];\n \n long long left = solve(steps - 1, arrLen, i - 1, dp);\n long long right = solve(steps - 1, arrLen, i + 1, dp);\n long long stay = solve(steps - 1, arrLen, i, dp);\n return dp[steps][i] = (long long)((left + right + stay) % mod);\n }\npublic:\n long long mod = 1e9 + 7;\n int numWays(int steps, int arrLen) {\n vector<vector<long long>> dp(steps + 1, vector<long long> (steps/2 + 1, -1));\n return (int)solve(steps, arrLen, 0, dp);\n }\n};\n```\n\n | 2 | 0 | ['Recursion', 'Memoization', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python3 Solution | python3-solution-by-motaharozzaman1996-16me | \n\n\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n mod=10**9+7\n n=min(arrLen,steps//2+1)\n ways=[1]+[0]*(n-1) | Motaharozzaman1996 | NORMAL | 2023-10-15T01:30:47.681550+00:00 | 2023-10-15T01:30:47.681571+00:00 | 105 | false | \n\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n mod=10**9+7\n n=min(arrLen,steps//2+1)\n ways=[1]+[0]*(n-1)\n for step in range(steps):\n ways=[sum(ways[max(0,i-1):i+2])%mod for i in range(min(step+2,steps-step,n))]\n return ways[0] \n``` | 2 | 0 | ['Python', 'Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅✅[C++] RECURSIVE DP SOLUTION || EASY TO UNDERSTAND || MEMOIZATION✅✅ | c-recursive-dp-solution-easy-to-understa-vz03 | \nconst int mod = 1e9+7;\n#define ll long long\nint dp[501][1000];\nclass Solution {\npublic:\n int f(int s,int a,int i=0){\n if(s==0 && i==0) return | Satyam_9766 | NORMAL | 2023-04-01T07:04:27.358535+00:00 | 2023-04-01T07:04:27.358584+00:00 | 487 | false | ```\nconst int mod = 1e9+7;\n#define ll long long\nint dp[501][1000];\nclass Solution {\npublic:\n int f(int s,int a,int i=0){\n if(s==0 && i==0) return 1;\n if(s==0||i<0||i==a) return 0;\n auto &it = dp[s][i];\n if(it!=-1)return it;\n return it = ((f(s-1,a,i)+f(s-1,a,i-1))%mod+f(s-1,a,i+1))%mod;\n }\n int numWays(int steps, int arrLen){\n memset(dp,-1,sizeof(dp));\n return f(steps,arrLen);\n\xA0\xA0\xA0\xA0}\n};\n``` | 2 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'C', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | c++ | easy | fast | c-easy-fast-by-venomhighs7-nw7e | \n\n# Code\n\n//from votrubac\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int sz = min(steps / 2 + 1, arrLen);\n vector<int> v1(s | venomhighs7 | NORMAL | 2022-11-24T04:19:31.966000+00:00 | 2022-11-24T04:19:31.966030+00:00 | 743 | false | \n\n# Code\n```\n//from votrubac\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n int sz = min(steps / 2 + 1, arrLen);\n vector<int> v1(sz + 2), v2(sz + 2);\n v1[1] = 1;\n while (steps-- > 0) {\n for (auto i = 1; i <= sz; ++i)\n v2[i] = ((long)v1[i] + v1[i - 1] + v1[i + 1]) % 1000000007;\n swap(v1, v2);\n }\n return v1[1];\n}\n};\n``` | 2 | 0 | ['C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [C++] Simplest Solution | Recursion -> Memorization | Easy Explanation | c-simplest-solution-recursion-memorizati-kksu | We need to return the no. of possible sequences where we take exaclty steps steps and reach 0 after that.\n\nRECURSION:\n\nCode:\n\nclass Solution {\n int mo | Mythri_Kaulwar | NORMAL | 2022-07-02T02:37:40.852967+00:00 | 2022-07-02T02:37:40.852995+00:00 | 382 | false | We need to return the no. of possible sequences where we take exaclty ```steps``` steps and reach ```0``` after that.\n\n**RECURSION:**\n\n**Code:**\n```\nclass Solution {\n int mod = pow(10, 9) + 7;\n vector<int> ways{0, -1, 1};\npublic:\n int numWays(int n, int len) {\n return solve(n, len);\n }\n \n int solve(int n, int len, int pos = 0) {\n if(n == 0 && pos == 0) return 1; //when we take exactly n steps and reach 0\n \n if(pos < 0 || pos >= len || n == 0 || pos > n) return 0;\n \n int ans = 0;\n for(int i=0; i<3; i++) {\n ans = (ans % mod + solve(n-1, len, pos + ways[i]) % mod) % mod;\n }\n \n return ans % mod; \n }\n};\n```\n\n**EXPLANATION:**\n\n* Firstly, we need to stop when ```pos > n``` because we will never be able to reach ```0```, if we keep on doing ```solve(n-1, len, pos+1)```.\n\n* The max value of ```pos``` possible so that we can reach ```0``` again by doing either of ```solve(n-1, len, pos-1)``` or ```solve(n-1, len, pos)``` is **n / 2**.\n\n**MEMORIZATION:**\n\n**Code:**\n```\nclass Solution {\n int mod = pow(10, 9) + 7;\n vector<int> ways{0, -1, 1};\n vector<vector<int>> dp;\npublic:\n int numWays(int n, int len) {\n dp.resize(n+1, vector<int>((n)/2 + 1, -1));\n return solve(n, len);\n }\n \n int solve(int n, int len, int pos = 0) {\n if(n == 0 && pos == 0) return 1;\n \n if(pos < 0 || pos >= len || n == 0 || pos > n) return 0;\n \n if(dp[n][pos] != -1) return dp[n][pos];\n \n int ans = 0;\n for(int i=0; i<3; i++) {\n ans = (ans % mod + solve(n-1, len, pos + ways[i]) % mod) % mod;\n }\n \n return dp[n][pos] = ans % mod;\n \n }\n};\n```\n\n**EXPLANATION:**\n\n* We have 2 variables here, the first being ```steps``` and the next ```pos```. So we initialize a 2D dp.\n\n* We ```pos``` to ```steps / 2``` as mentioned before. | 2 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'C', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python 3 DP, 97% Time, 96% Space | python-3-dp-97-time-96-space-by-weichich-dqnb | It\'s the standard DP where dp[i] represents how many ways to reach ith index, with the following optimization:\n1. Using a single list instead of 2D lists, sin | weichichi | NORMAL | 2021-10-27T23:50:17.901319+00:00 | 2021-10-29T19:29:33.309806+00:00 | 194 | false | It\'s the standard DP where `dp[i]` represents how many ways to reach ith index, with the following optimization:\n1. Using a single list instead of 2D lists, since we only have to look back 1 step, we only need to keep 1 value, the overriden value can simply be stored in a tmp variable\n2. No matter how large ```arrLen``` is, the number of reachable index is limited by steps. Even if the array is 200 element long, if you only have 2 steps, the furthest you can reach is the 2nd element, so ```min(steps, arrLen)``` is enough.\n3. Notice that if you move left, you must also at some point move right to get back to the 0th spot, so in order to reach original spot, the furthest you\'re allowed to go is ```(steps / 2)```th index, which is the ```(steps / 2) + 1``` element. Everything past that is meaningless, since regardless of how many ways you can reach there, you won\'t make it back.\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n maxLength = min(int(steps / 2) + 1, arrLen)\n if (maxLength == 1): return 1 #if there\'s only 1 step, or 1 element, there\'s only 1 way\n dp = [0] * maxLength\n dp[0], dp[1] = 1, 1 #first step\n for i in range(1, steps): #starting from second step\n tmp = 0 #tmp variable to hold old value\n for j in range(maxLength):\n tmp_old = tmp\n tmp = dp[j]\n if j > 0:\n dp[j] += tmp_old\n if j < maxLength - 1:\n dp[j] += dp[j + 1]\n return(dp[0] % 1000000007)\n```\n | 2 | 0 | ['Dynamic Programming', 'Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | python | 100%/100% - DP - commented with a full explanation | python-100100-dp-commented-with-a-full-e-epos | Ok, so I\'ve just looked at other people\'s solutions, and nothing I\'ve done here is particularly new, I just did a pretty good job at optimizing the method. T | queenTau | NORMAL | 2021-05-16T00:33:53.069818+00:00 | 2021-08-02T04:55:30.111026+00:00 | 343 | false | Ok, so I\'ve just looked at other people\'s solutions, and nothing I\'ve done here is particularly new, I just did a pretty good job at optimizing the method. The basic idea is that if we know the number of ways to reach each position after k steps, then we can compute the number of ways to reach each position after k + 1 steps using the equation:\n\nways[k + 1][i] = ways[k][i - 1] + ways[k][i] + ways[k][i + 1]\n\nFor example: steps = 4, arrLen = 4:\n\nk : #ways to reach each position after exactly k steps\n0 : [1, 0, 0, 0]\n1 : [1, 1, 0, 0]\n2 : [2, 2, 1, 0]\n3 : [4, 5, 3, 1]\n4 : [9, 12, 9, 4]\n\nThe final answer is 9, because that is the number of ways to reach position 0 after exactly 4 steps.\n\nThere are a few optimizations which can be made here though. First, we can always start after 1 step because after 1 step the array will always look like: [1, 1, 0, 0, ..., 0] (unless arrLen == 1, in which case the answer to the problem is 1). Second, we only need to store a single row of the \'ways\' dp table at a time, because we can use a window sum and some dummy memory to update the row to get the next row using less time and less memory. Third, if you look at the example above, there\'s a value of 1 which propagates to the right 1 index each iteration. This means that when we\'re updating the row we don\'t have to compute anything past that. Similarly, when we\'re later in the computation, we run into the case where the position we\'re at might be greater than the number of steps we have remaining. These positions can no longer affect the number of ways to reach position 0, so we don\'t need to keep updating them each iteration. Finally, if we think about the last idea some more, we can realize that we might not even need the whole array to begin with, because there might be positions which never affect the result (it turns out that this saves quite a bit of memory over the test cases used). I\'ll demonstrate this with another example:\n\nsteps = 3, arrLen = 10\n\nk : #ways to reach each position after exactly k steps : truncated : necessary calculations only\n1 : [1, 1, 0, 0, 0, 0, 0, 0, 0, 0] : [1, 1] : [1, 1]\n2 : [2, 2, 1, 0, 0, 0, 0, 0, 0, 0] : [2, 2] : [2, 2]\n3 : [4, 5, 3, 1, 0, 0, 0, 0, 0, 0] : [4, 4] : [4, 2] (position 1 wasn\'t updated since we didn\'t need it to be)\n\nIn this example, even though the array length was 10, we actually only needed the first 2 positions in order to get the answer 4 because we were only taking 3 steps. (3//2 + 1 = 2 is the actual equation used - in my code I actually pad with an extra zero as well to take care of an edge case). Had we taken a 4th step though then this truncation would not be sufficient and we would require an additional element in the ways array to get the correct answer.\n\nThe last couple optimizations I used were to reduce the sum (mod 1000000007) at every step (to avoid big integers), and to use 2 separate variables to keep track of my sliding window instead of a list (I assume this is faster because there\'s less overhead, but I don\'t actually know for sure - I tested it both ways though and this was faster though, so... If anyone does know for sure though please let me know!).\n\nFinally, I want to note that when doing a sliding window sum like this it\'s usually better to keep track of the sum itself and then subtract and old value while adding a new value at each step. This isn\'t faster in this case though because it would require the same number of additions at each step, and it requires 2 additional integers of memory, each of which would need to be updated at each step. So in this particular case it is faster to just compute the entire sum each time, even though that does involve a little recomputation.\n\nPerformance:\nTime Complexity: O(steps\\*min(arrLen, steps/2))\nMemory Complexity: O(min(arrLen, steps/2))\nBest Result: 88 ms/14 MB : 100%/100%\n\n\'\'\'\nclass Solution:\n\n def numWays(self, steps: int, arrLen: int) -> int:\n\t\t#Check for Trivial Cases (This Isn\'t Strictly Necessary)\n if arrLen == 1 or steps == 1:\n return 1\n\t\t\n #Initialize A Tables of The Number of Ways (With A Zero Padded on the Right)\n ways = [0]*min(arrLen + 1, steps//2 + 2)\n ways[0] = 1\n ways[1] = 1\n \n #Propagate the Values\n\t\tmod = 1000000007\n for step in range(1, steps):\n #Initialize Some Memory to Track the Sliding Window (Implicitly Padding a Zero on the Left)\n a, b = 0, ways[0]\n \n #Update the Number of Ways to Reach Each Relavent Position (After \'step + 1\' Steps)\n for j, i in enumerate(range(min(step + 2, arrLen, steps - step)), start = 1):\n #Update the Number of Ways to Reach Position i\n ways[i] = (a + b + ways[j])%mod\n \n #Update the Memory\n a, b = b, ways[j]\n \n #Return the Solution\n return ways[0]\n\'\'\' | 2 | 0 | ['Dynamic Programming', 'Python'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [C++] Optimized DP solution | c-optimized-dp-solution-by-justkj-xhvg | \nint numWays(int steps, int arrLen) {\n int mod = 1e9 + 7;\n vector<int> dp(min(steps/2+1, arrLen), 0);\n dp[0] = 1;\n while (steps | justkj | NORMAL | 2021-04-08T05:44:27.375625+00:00 | 2021-04-08T05:44:42.829987+00:00 | 273 | false | ```\nint numWays(int steps, int arrLen) {\n int mod = 1e9 + 7;\n vector<int> dp(min(steps/2+1, arrLen), 0);\n dp[0] = 1;\n while (steps-- > 0) {\n vector<int> new_dp(dp.size(), 0);\n for (int i = 0; i < dp.size(); ++i) {\n if (i > 0) new_dp[i-1] = (new_dp[i-1] + dp[i]) % mod;\n new_dp[i] = (new_dp[i] + dp[i]) % mod;\n if (i < dp.size()-1) new_dp[i+1] = (new_dp[i+1] + dp[i]) % mod;\n }\n dp = new_dp;\n }\n return dp.front();\n }\n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Classic DP Bottom Up approach | classic-dp-bottom-up-approach-by-lysyi-u87a | Let\'s begin with recursive reasoning.\nAt each step there are three posibilities for an action\n1. stay\n2. go left if position > 0\n3. go right if position < | lysyi | NORMAL | 2021-01-03T09:08:23.509103+00:00 | 2021-01-03T09:08:23.509136+00:00 | 138 | false | Let\'s begin with recursive reasoning.\nAt each step there are three posibilities for an action\n1. stay\n2. go left if position > 0\n3. go right if position < arrLen - 1\nIf we are on the final step and position = 0 then the sequence of step is correct and should be counted.\nThis idea can be coded directly\n```java\n\tprivate final int MOD = 1000_000_007;\n // time : O(3^s), where is the number of steps\n // space: O(s)\n private long backtrack(int step, int pos, int steps, int len) {\n if(step == steps) {\n if(pos == 0) {\n return 1;\n }\n return 0;\n }\n long ways = backtrack(pos, step + 1, steps, len) % MOD; // stay\n if(pos > 0) {\n ways += backtrack(pos - 1, step + 1, steps, len) % MOD; // go left\n }\n if(pos < len - 1) {\n ways += backtrack(pos + 1, step + 1, steps, len ) % MOD; // go right\n }\n return ways;\n } \n \n public int numWays(int steps, int arrLen) {\n return (int) backtrack(0, 0, steps, arrLen) % MOD;\n }\n```\nThis solution is too slow (exponential complexity), but applying memoization helps to pass all test cases\n```java\n private int MOD = 1000_000_007;\n \n private Map<Pair<Integer,Integer>, Long> memo = new HashMap<>();\n \n private long backtrack(int step, int pos, int steps, int arrLen){\n if(step == steps) {\n if(pos == 0) {\n return 1;\n }\n return 0;\n }\n Pair<Integer, Integer> key = new Pair(pos, step);\n if(memo.containsKey(key)){\n return memo.get(key);\n }\n long ways = backtrack(step + 1, pos, steps, arrLen) % MOD; // stay\n if(pos > 0) {\n ways += backtrack(step + 1, pos - 1, steps, arrLen) % MOD; // go left\n }\n if(pos < arrLen - 1) {\n ways += backtrack(step + 1, pos + 1, steps, arrLen) % MOD; // go right\n }\n memo.put(key, ways);\n return ways;\n }\n \n public int numWays(int steps, int arrLen) {\n return (int) backtrack(0, 0, steps, arrLen) % MOD;\n }\n```\nNow this solution can be directly transformed to Dynamic Programming Botton Up form by replacing call to the recursive function backtrack(step, ) with a table lookup **dp[step, position]**.\nThe only gotcha here is the possible length of the array ( 1 <= arrLen <= 1000_000) . Having such a big table takes too much memory. Notice that if we go too far from 0 position, it would not be possible to go back after all steps are exhausted. So the maximum reach of the pointer is min(steps/2 + 1, arrLen). \n\n```\n\tprivate final int MOD = 1000_000_007;\n\t\n\tpublic int numWays(int steps, int arrLen) {\n int max = Math.min(steps/2 + 1, arrLen);\n long[][] dp = new long[steps + 1][max];\n dp[0][0] = 1; // base case\n for(int step = 1; step <= steps; step++) {\n for(int pos = 0; pos <= step && pos < max; pos++) {\n dp[step][pos] = dp[step - 1][pos] % MOD; // stay\n if(pos < max - 1) {\n dp[step][pos] += dp[step - 1][pos + 1] % MOD; // right\n }\n if(pos > 0) {\n dp[step][pos] += dp[step - 1][pos - 1] % MOD; // left\n }\n }\n }\n return (int) dp[steps][0] % MOD;\n }\n```\nThe time and space complexity is now O(s^2) and doesn\'t depend on the length of the array. Although this is not the fastest solution is it easy to follow unlike many posted below and has classic DP template. It\'s possible to easy optimize it to beat 98% just by replacing long with int (long type takes more RAM and CPU cycles for computation), but it\'s up to you. For interview purpose it\'s enough. | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [Rust] 4ms | rust-4ms-by-nickx720-uzjd | \nimpl Solution {\n pub fn num_ways(steps: i32, arr_len: i32) -> i32 {\n let steps = steps as usize;\n let mut dp: Vec<Vec<i32>> = vec![vec![0; ste | nickx720 | NORMAL | 2020-10-30T13:14:42.862424+00:00 | 2020-10-30T13:14:42.862469+00:00 | 71 | false | ```\nimpl Solution {\n pub fn num_ways(steps: i32, arr_len: i32) -> i32 {\n let steps = steps as usize;\n let mut dp: Vec<Vec<i32>> = vec![vec![0; steps + 1]; steps + 1];\n for i in 1..=steps {\n let mut j: usize = 0;\n loop {\n if j <= i && j < arr_len as usize {\n dp[i][j] = 1;\n } else {\n break;\n }\n j += 1;\n }\n }\n let modu: i32 = (10u32.pow(9) + 7) as i32;\n for i in 2..=steps {\n let mut j: usize = 0;\n loop {\n if j <= i && j < arr_len as usize {\n let left = if j == 0 { 0 } else { dp[i - 1][j - 1] };\n let res = (left + dp[i - 1][j]) % modu;\n let right = if j >= i || j >= arr_len as usize {\n 0\n } else {\n dp[i - 1][j + 1]\n };\n dp[i][j] = (res + right) % modu;\n } else {\n break;\n }\n j += 1;\n }\n }\n dp[steps][0]\n }\n}\n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Easy to understand Python DFS + Memoization | easy-to-understand-python-dfs-memoizatio-r4rz | Do a dfs search which giving current step and idx, the next state we can move to is:\n\nLeft: dfs(step - 1, idx - 1)\nRight: dfs(step - 1, idx + 1)\nStay: | hao95 | NORMAL | 2020-10-24T22:41:56.353410+00:00 | 2020-10-24T22:43:31.540421+00:00 | 151 | false | Do a dfs search which giving current **step** and **idx**, the next state we can move to is:\n\nLeft: dfs(step - 1, idx - 1)\nRight: dfs(step - 1, idx + 1)\nStay: dfs(step - 1, idx)\nCurrent result wil be the sum of above function calls\' result.\n\nAnd search ending condition is:\n* if idx is out of range\n* step == 0\n\nWith memoization:\nTime Complexicty: O(step * arrLen)\nSpace Complexity: O(step * arrLen)\n\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n cache = dict()\n def dfs(step, idx):\n if (step, idx) in cache:\n return cache[(step, idx)]\n if idx >= arrLen or idx < 0: # The pointer should not be placed outside the array at any time\n return 0\n if step == 0: \n return 1 if idx == 0 else 0 # pointer should still at index 0 after exactly steps steps \n cache[(step, idx)] = (dfs(step - 1, idx) + dfs(step - 1, idx - 1) + dfs(step - 1, idx + 1)) % (10**9 + 7)\n return cache[(step, idx)]\n return dfs(steps, 0)\n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Javascript Heap Out Of Memory Even after using DP and BigInt HELP? | javascript-heap-out-of-memory-even-after-t4nh | Here is what it does.\n\n\n```\n/*\n * @param {number} steps\n * @param {number} arrLen\n * @return {number}\n /\nvar numWays = function(steps, arrLen) {\n c | lgdelacruz | NORMAL | 2020-09-05T16:48:22.159459+00:00 | 2020-09-05T16:48:22.159505+00:00 | 1,796 | false | Here is what it does.\n\n\n```\n/**\n * @param {number} steps\n * @param {number} arrLen\n * @return {number}\n */\nvar numWays = function(steps, arrLen) {\n const memo = [];\n for (let i = 0; i < arrLen + 2; i++) {\n const row = [];\n for (let j = 0; j <= steps; j++) {\n row.push(BigInt(0));\n }\n memo.push(row);\n }\n\n memo[1][steps] = BigInt(1);\n memo[2][steps] = BigInt(0);\n const mod = BigInt(10 ** 9 + 7);\n for (let j = steps - 1; j >= 0; j--) {\n for (let i = arrLen - 1; i >= 0; i--) {\n memo[i + 1][j] = memo[i + 1 - 1][j + 1] + memo[i + 1][j + 1] + memo[i + 1 + 1][j+1];\n memo[i + 1][j] %= mod;\n }\n }\n\n return memo[1][0];\n}; | 2 | 0 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java solution from TLE to Accepted | java-solution-from-tle-to-accepted-by-ml-z9mh | This problem is very straightforward, most of you must have already figured out what could be the dynamic programming equation which is DP[i][s] - number of way | mlogn | NORMAL | 2020-08-30T18:42:35.318416+00:00 | 2020-08-30T18:49:39.085585+00:00 | 151 | false | This problem is very straightforward, most of you must have already figured out what could be the dynamic programming equation which is `DP[i][s] - number of ways to reach at index i after taking exactly s steps` so DP equation will be `DP[i][s] = DP[i-1][s-1] + DP[i][s-1] + DP[i+1][s-1]`.\nSince `dp equation` only depends on `last row`, we can perform some space reduction to optimise the space.\n\n```java\nclass Solution {\n int[] moves = {-1,0,1};\n int MOD = 1000000000 + 7;\n\n public int numWays(int steps, int arrLen) {\n\t arrLen++;\n int[] dp = new int[arrLen];\n dp[0] = 1;\n while (--steps >= 0) {\n int[] dpNext = new int[arrLen];\n for (int i = 0; i < arrLen; i++) {\n for (int d: moves) {\n if (i + d >= 0 && i+d < arrLen) {\n dpNext[i] = (dpNext[i] + dp[i+d]) % MOD;\n }\n }\n }\n dp = dpNext;\n }\n return dp[0];\n }\n}\n```\n\n**Time**: `O(S * N)`\n**Space**: `O(S)`\nsince constraints are very high so TLE is expected. How can we reduce the time ?\n\n**Optimization #1 to overcome TLE**\nBy carefully oberserving the problem and constraint, we can say that maximum index that we can reach in the array is S, so solving problem for any index after S is useless, so let\'s `arrLen = Math.min(S, arrLen)+1`\n\n**Time**: `O(S * min(S, N))` whose upperbound is `O(S*S)`\n**Space**: `O(S)`\n\n```java\nclass Solution {\n int[] moves = {-1,0,1};\n int MOD = 1000000000 + 7;\n\n public int numWays(int steps, int arrLen) {\n arrLen = Math.min(arrLen, steps + 1); // just add this line\n int[] dp = new int[arrLen];\n dp[0] = 1;\n while (--steps >= 0) {\n int[] dpNext = new int[arrLen];\n for (int i = 0; i < arrLen; i++) {\n for (int d: moves) {\n if (i + d >= 0 && i+d < arrLen) {\n dpNext[i] = (dpNext[i] + dp[i+d]) % MOD;\n }\n }\n }\n dp = dpNext;\n }\n return dp[0];\n }\n}\n```\n\n**Another optimization to improve the solution**\nSince we\'ve to reach at index 0 so if we go beyond `S/2 + 1` (+1 in case of odd) we will never be able to return at index 0, so only solve problem for `Math.min(N, S/2+1)`\n\nFinal Code\n\n```java\nclass Solution {\n int[] moves = {-1,0,1};\n int MOD = 1000000000 + 7;\n\n public int numWays(int steps, int arrLen) {\n arrLen = Math.min(arrLen, steps/2 + 1); // just add this line\n int[] dp = new int[arrLen];\n dp[0] = 1;\n while (--steps >= 0) {\n int[] dpNext = new int[arrLen];\n for (int i = 0; i < arrLen; i++) {\n for (int d: moves) {\n if (i + d >= 0 && i+d < arrLen) {\n dpNext[i] = (dpNext[i] + dp[i+d]) % MOD;\n }\n }\n }\n dp = dpNext;\n }\n return dp[0];\n }\n}\n```\n\n**Time**: `O(S * min(S, N))` whose upperbound is `O(S*S)`\n**Space**: `O(S)` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java Recursion + Memo | java-recursion-memo-by-jyotiprakashrout4-sto3 | \nclass Solution {\n \n public int numWays(int steps, int arrLen) {\n int[][] memo = new int[steps + 1][steps + 1];\n return helper(steps , | jyotiprakashrout434 | NORMAL | 2020-07-31T22:45:30.567838+00:00 | 2020-07-31T22:45:30.567873+00:00 | 294 | false | ```\nclass Solution {\n \n public int numWays(int steps, int arrLen) {\n int[][] memo = new int[steps + 1][steps + 1];\n return helper(steps , arrLen , 0 , memo );\n }\n \n private int helper(int moves , int N , int i , int[][]memo){\n \n if(i > moves){\n return 0 ;\n }\n \n if(moves == 0 && i == 0){\n return 1;\n }\n \n if(memo[moves][i] != 0){\n return memo[moves][i];\n }\n \n int res = 0 , MOD = 1_000_000_007;\n \n res = helper(moves - 1 , N , i , memo) % MOD; \n \n if(i > 0){\n res = ( res % MOD + helper(moves - 1 , N , i - 1 , memo) % MOD ) % MOD;\n }\n if( i < N - 1){\n res = ( res % MOD + helper(moves - 1 , N , i + 1 , memo) % MOD ) % MOD;\n }\n \n memo[moves][i] = res;\n \n return res; \n \n }\n \n \n}\n``` | 2 | 0 | ['Recursion', 'Memoization', 'Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python 3, DFS with memoization | python-3-dfs-with-memoization-by-timzeng-6fp5 | \nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps == 0 or arrLen == 1:\n return 1\n \n vi | timzeng | NORMAL | 2020-05-26T05:08:01.977342+00:00 | 2020-05-26T05:08:01.977392+00:00 | 240 | false | ```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n if steps == 0 or arrLen == 1:\n return 1\n \n visited = {}\n return self.helper(0, steps, arrLen, visited) % (10 ** 9 + 7)\n \n def helper(self, pos, steps, n, visited):\n if (pos, steps) in visited:\n return visited[(pos, steps)]\n if steps == 0:\n if pos == 0:\n return 1\n else:\n return 0\n if pos > steps:\n return 0\n res = self.helper(pos, steps-1, n, visited)\n if 0<=pos+1<n:\n res += self.helper(pos+1, steps-1, n, visited)\n if 0<=pos-1<n:\n res += self.helper(pos-1, steps-1, n, visited) \n visited[(pos, steps)] = res\n return visited[(pos, steps)]\n``` | 2 | 0 | ['Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python3 DP O(n) space | python3-dp-on-space-by-mictw-44y4 | \npython\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n N, MOD = min(steps, arrLen), 10**9+7\n moves = [1] + [0]*N\n | mictw | NORMAL | 2020-04-04T22:33:50.585020+00:00 | 2020-04-04T22:33:50.585067+00:00 | 183 | false | \n```python\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n N, MOD = min(steps, arrLen), 10**9+7\n moves = [1] + [0]*N\n for s in range(steps):\n pre = 0\n for i in range(N):\n pre, moves[i] = (moves[i], (pre + moves[i] + moves[i+1]) % MOD)\n # moves[i] = k if there\'s k ways to move from i to 0 in s+1 steps\n return moves[0]\n``` | 2 | 0 | ['Dynamic Programming', 'Python3'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | TLE--> Memoization -- > bottomup DP[with easy to understand comments] | tle-memoization-bottomup-dpwith-easy-to-14mag | TLE: \n\nclass Solution {\n public int numWays(int steps, int arrLen) {\n return dfs(steps,arrLen,0);\n }\n \n int dfs(int steps,int len,int | sr2311 | NORMAL | 2020-03-26T16:01:23.158647+00:00 | 2020-03-26T16:01:23.158699+00:00 | 124 | false | TLE: \n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n return dfs(steps,arrLen,0);\n }\n \n int dfs(int steps,int len,int index){\n \n int left,right,stay;\n left=right=stay=0;\n \n if(index< 0 || index ==len) // base case when we go out of array\n return 0;\n if(steps==0 && index==0){//when we have the desired condition met and no more steps are left\n return 1;\n }\n if(steps==0)// steps is 0 and and index is not equal to target position ( 0 )\n return 0;\n \n left=dfs(steps-1,len,index-1);//jump left\n right=dfs(steps-1,len,index+1);//jump right\n stay=dfs(steps-1,len,index);//stay there\n return left+right+stay;\n }\n}\n```\n\nMemoization/top down approach:\nHere we remember our steps and index in a HashMap to avoid recomputation of same state again and again\n\n```\nclass Solution {\n final int mod=1000000007;\n HashMap<String,Integer> map=new HashMap<>();\n public int numWays(int steps, int arrLen) {\n return dfs(steps,arrLen,0);\n }\n \n int dfs(int steps,int len,int index){\n \n int left,right,stay;\n left=right=stay=0;\n \n if(index< 0 || index ==len)\n return 0;\n if(steps==0 && index==0){\n return 1;\n }\n if(steps==0)\n return 0;\n if(map.containsKey(index+ " "+steps))//checking if same state has been calculated\n return map.get(index+" "+steps);\n \n left=dfs(steps-1,len,index-1);\n right=dfs(steps-1,len,index+1);\n int x= (left+right)%mod;\n stay=(dfs(steps-1,len,index)+x)%mod;\n map.put(index+ " "+steps,stay);//rememebering the state\n return stay;\n }\n}\n\n```\n\nDP/bottom up\nHere to avoid recursion we start from a state when we had 0 steps, then go to a state when we had 1 step then go to a state when we had 2 steps and so on untils given number of steps.\n```\nclass Solution {\n public int numWays(int steps, int arrLen) {\n int k=Math.min(steps,arrLen);//this is done to avoid memeory limit exceeded error\n //Intuition : our target position is bounded by index 0 so we know maxim to the right we can go is steps and after that you cannot jump thus we take min(arrLen,steps)\n int dp[][]=new int[steps+1][k];\n dp[0][0]=1;\n \n for(int i=1;i<=steps;i++){\n for(int j=0;j<k;j++){\n if(j-1<0){\n dp[i][j]=(dp[i-1][j+1]+dp[i-1][j])%1000000007;\n \n }\n else if(j+1==k){\n dp[i][j]=(dp[i-1][j-1]+dp[i-1][j])%1000000007;\n }\n else{\n dp[i][j]=((dp[i-1][j-1]+dp[i-1][j])%1000000007+dp[i-1][j+1])%1000000007;\n }\n }\n }\n return dp[steps][0];\n }\n}\n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Accepted C# DP Solution | accepted-c-dp-solution-by-maxpushkarev-009n | \n public class Solution\n {\n private const int MODULO = 1_000_000_007;\n\n public int NumWays(int steps, int arrLen)\n {\n | maxpushkarev | NORMAL | 2020-03-23T12:33:44.237886+00:00 | 2020-03-23T12:33:44.237923+00:00 | 100 | false | ```\n public class Solution\n {\n private const int MODULO = 1_000_000_007;\n\n public int NumWays(int steps, int arrLen)\n {\n checked\n {\n int maxIdx = Math.Min(steps, arrLen - 1);\n int[,] dp = new int[steps + 1, maxIdx + 1];\n\n dp[0, 0] = 1;\n\n for (int i = 1; i <= steps; i++)\n {\n for (int j = 0; j <= maxIdx; j++)\n {\n //stay\n dp[i, j] = dp[i - 1, j];\n //left\n if (j > 0)\n {\n dp[i, j] += dp[i - 1, j - 1];\n dp[i, j] %= MODULO;\n }\n //right\n if (j < maxIdx)\n {\n dp[i, j] += dp[i - 1, j + 1];\n dp[i, j] %= MODULO;\n }\n }\n }\n\n return dp[steps, 0];\n }\n }\n }\n``` | 2 | 0 | ['Dynamic Programming'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Key point of fast DP. | key-point-of-fast-dp-by-specialforceatp-hp9l | Let DP[i] denote the number of ways to get to position i after n steps, for the n+1 th step, we have the recurrence relation DP[i] = DP[i] + DP[i-1]+DP[i+1]. Th | specialforceatp | NORMAL | 2020-02-06T04:29:25.339808+00:00 | 2020-02-06T04:29:25.339861+00:00 | 127 | false | Let DP[i] denote the number of ways to get to position i after n steps, for the n+1 th step, we have the recurrence relation DP[i] = DP[i] + DP[i-1]+DP[i+1]. The DP solution solves the problem in O(arrLen*steps) and gets a TLE in some test cases.\n\nThe key point to improve it is, when arrlen is larger than steps, for position i>steps, DP[i] will always be zero because we don\'e have enough steps to get there. For the test case arrlen=100000 and steps=400, the difference in runtime is significant.\n\nFurther more, not only positions i>steps are irrelavent, positions i>steps/2+1 are all irrelavent. Because for those positions, it takes more than half of the steps to get there and there are not enough steps to go back to zero. \n\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n L = min(arrLen, int(steps/2)+1)\n if not L:\n return 0\n if L==1:\n return 1\n dp = [0]*L\n dp[0] = 1\n dp[1] = 1\n for i in range(steps-1):\n dp1 = [0]*L\n dp1[0] = dp[0] + dp[1]\n for j in range(1,L-1):\n dp1[j] = dp[j-1] + dp[j] + dp[j+1]\n dp1[L-1] = dp[L-2] + dp[L-1]\n dp = dp1\n #print(dp)\n return dp[0]%(10**9 + 7)\n \n \n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Share the dp | share-the-dp-by-sparkbean-wyou | java\n 0 1 2 3 \n -----------------\n 0| 0 | 0 | 0 | 0 |\n -----------------\n 1| 1 | 1 | 2 | 4 |\n -----------------\n 2| 0 | 1 | 2 | 4 | \n ----- | sparkbean | NORMAL | 2019-11-24T20:24:43.738592+00:00 | 2019-11-24T20:24:43.738637+00:00 | 96 | false | ```java\n 0 1 2 3 \n -----------------\n 0| 0 | 0 | 0 | 0 |\n -----------------\n 1| 1 | 1 | 2 | 4 |\n -----------------\n 2| 0 | 1 | 2 | 4 | \n -----------------\n```\nThis table is the dp table of the given example. The line index means the position in the array, the column index means the current step, and dp\\[ i ][ j ] means the ways that *after j steps, arrived at index i*. I first tried using 2D dp to solve this problem, I got TLE or MLE. Then I used 1D dp to solve the problem. | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Java 6ms 1D-DP | java-6ms-1d-dp-by-tmazur-bzya | We count the number of ways we can get to each position in array at each step.\n\nIntuition: \n1. For step 1, we can always reach, idx=0, and idx=1 in one way.\ | tmazur | NORMAL | 2019-11-24T05:01:11.099725+00:00 | 2019-11-24T05:01:11.099760+00:00 | 185 | false | We count the number of ways we can get to each position in array at each step.\n\nIntuition: \n1. For step 1, we can always reach, idx=0, and idx=1 in one way.\n2. For each following step, we can get to each position by summing the neiboring positions from the previous step.\n\n```\nclass Solution {\n \n private final static int MOD = 1000000007;\n public int numWays(int steps, int arrLen) {\n int limit = Math.min(arrLen, steps/2+1);\n int[] pos = new int[1000001];\n pos[0] = 1;\n pos[1] = 1;\n for(int i = 1; i < steps; ++i) {\n int j = 0;\n int prev = 0;\n while(j < limit && pos[j] > 0) {\n int pp = pos[j];\n pos[j] = (((prev + pos[j]) % MOD) + pos[j+1]) % MOD;\n prev = pp;\n j++;\n }\n if(j < limit) {\n pos[j]++;\n }\n }\n \n return pos[0];\n }\n}\n``` | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++ Intuitive Solution Recursion With Memoization | c-intuitive-solution-recursion-with-memo-00ih | The key factor was that array Length was of the order of 1000000. But we can clearly observe that the arrayLength won\'t matter if it exceeds the number of step | gagandeepahuja09 | NORMAL | 2019-11-24T04:04:35.452582+00:00 | 2019-11-24T04:18:51.279343+00:00 | 271 | false | The key factor was that array Length was of the order of 1000000. But we can clearly observe that the arrayLength won\'t matter if it exceeds the number of steps. Hence we can write\n\n```\n if(len > steps)\n len = steps;\n```\n\n**Code:**\n\n\n\n```\n#define ll long long int\n\nclass Solution {\npublic:\n \n ll dp[501][501];\n ll MOD = 1e9 + 7;\n ll f(int steps, int i, int len) {\n if(i >= len || i < 0)\n return 0;\n if(steps == 0)\n return (i == 0);\n if(dp[steps][i] != -1)\n return dp[steps][i];\n ll op1 = f(steps - 1, i + 1, len) % MOD;\n ll op2 = f(steps - 1, i - 1, len) % MOD;\n ll op3 = f(steps - 1, i, len) % MOD;\n return dp[steps][i] = (op1 + op2 + op3) % MOD;\n }\n \n int numWays(int steps, int len) {\n memset(dp, -1, sizeof dp);\n if(len > steps)\n len = steps;\n return (int)(f(steps, 0, len) % MOD);\n return 0;\n }\n};\n``` | 2 | 1 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python top-down DP solution | python-top-down-dp-solution-by-otoc-fnko | \n def numWays(self, steps: int, arrLen: int) -> int:\n def recursive(x, n):\n mod = 10 ** 9 + 7\n if n == x:\n r | otoc | NORMAL | 2019-11-24T04:03:31.098570+00:00 | 2019-12-04T01:23:58.446656+00:00 | 205 | false | ```\n def numWays(self, steps: int, arrLen: int) -> int:\n def recursive(x, n):\n mod = 10 ** 9 + 7\n if n == x:\n return 1\n if n == 0 or x > n:\n return 0\n if (x, n) in dp:\n return dp[(x, n)]\n dp[(x, n)] = recursive(x, n - 1)\n if x - 1 >= 0:\n dp[(x, n)] = (dp[(x, n)] + recursive(x - 1, n - 1)) % mod\n if x + 1 < arrLen:\n dp[(x, n)] = (dp[(x, n)] + recursive(x + 1, n - 1)) % mod\n return dp[(x, n)]\n\t\t\n\t\tdp = dict()\n return recursive(0, steps)\n``` | 2 | 1 | [] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [C++] DP | c-dp-by-orangezeit-0c8p | \nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n\t\t// the length of DP should be min of arrLen and steps / 2 + 1, otherwise we may have | orangezeit | NORMAL | 2019-11-24T04:03:24.693073+00:00 | 2019-11-24T20:30:34.197325+00:00 | 277 | false | ```\nclass Solution {\npublic:\n int numWays(int steps, int arrLen) {\n\t\t// the length of DP should be min of arrLen and steps / 2 + 1, otherwise we may have TLE\n\t\t// if you reach beyond steps / 2 + 1, you will never come back to 0\n\t\tconst int len(min(steps / 2 + 1, arrLen)), mod(1e9 + 7);\n vector<long> dp(len);\n dp[0] = 1;\n \n while (steps--) {\n vector<long> new_dp(len);\n for (int i = 0; i < len; ++i) {\n\t\t\t\t// for each point in the middle, we either stay or go left or go right\n\t\t\t\t// at end points, we only have two options\n new_dp[i] = (dp[i] + (i ? dp[i-1] : 0) + (i < len - 1 ? dp[i+1] : 0)) % mod;\n\t\t\t\t// slight improvement: we break the loop of we find new_dp[i] is 0\n\t\t\t\t// since by deduction, any point beyond i is also 0\n if (!new_dp[i]) break;\n }\n swap(dp, new_dp);\n }\n \n return dp[0];\n }\n};\n``` | 2 | 0 | ['Dynamic Programming'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Python - Simple memoization | python-simple-memoization-by-cool_shark-v4j9 | py\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n def recurse(idx, cnt):\n if cnt == steps:\n if id | cool_shark | NORMAL | 2019-11-24T04:01:56.617708+00:00 | 2019-11-24T04:01:56.617742+00:00 | 194 | false | ```py\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n def recurse(idx, cnt):\n if cnt == steps:\n if idx == 0:\n return 1\n return 0\n if (idx, cnt) in memo:\n return memo[(idx,cnt)]\n ways = 0\n if 0 <= idx < arrLen - 1:\n ways += recurse(idx+1, cnt+1)\n if 0 < idx < arrLen:\n ways += recurse(idx-1, cnt+1)\n if 0 <= idx < arrLen:\n ways += recurse(idx, cnt+1)\n memo[(idx,cnt)] = ways\n return memo[(idx,cnt)]\n memo = {}\n return recurse(0,0) % (10**9 + 7) \n```\t\t | 2 | 0 | [] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Simple python solution using recursion + Top-down approach + simple memorization with cache | simple-python-solution-using-recursion-t-3jcd | IntuitionThe problem is about counting the number of ways to return to position 0 after a specific number of steps. Since we can move left, right, or stay, it f | Adi125 | NORMAL | 2025-01-20T09:08:17.877743+00:00 | 2025-01-20T09:08:17.877743+00:00 | 21 | false | # Intuition
The problem is about counting the number of ways to return to position `0` after a specific number of steps. Since we can move left, right, or stay, it feels like a problem that can be solved by exploring all possible moves recursively.
To avoid recomputing the same states, we can use memoization to speed up the process. In python we can use `@cache` decorator to do this and store past calls.
# Approach
1. Define a recursive helper function `helper(position, steps)` that computes the number of ways to reach position `0` with the given steps remaining.
2. Our base cases:
- If `position` is out of bounds, return 0 (invalid).
- If `steps == 0` and `position == 0`, return 1 (valid way).
- If `steps == 0` and `position != 0`, return 0 (invalid way).
3. For each recursive call, consider:
- Staying in the same position.
- Moving one step to the left
- **Note:** If `position == 0` we can't go left
- Moving one step to the right.
4. Use memoization to store results for `(position, steps)` to avoid redundant calculations via `@cache`
5. Start the recursion from `helper(0, steps)` and return the result modulo \(10^9 + 7\).
# Complexity
- **Time complexity:** $$O(Steps∗Arrlen)$$
- **Space complexity:** $$O(Steps∗Arrlen)$$ (we have these make recursive calls on the call stack)
# Code
```python3 []
class Solution:
def numWays(self, steps: int, arrLen: int) -> int:
@cache
def helper(position,steps,arrLen):
if position > arrLen:
return 0
if position == 0 and steps == 0:
return 1
elif position != 0 and steps == 0:
return 0
elif position == 0 and steps != 0:
stay = helper(position,steps-1,arrLen)
right = helper(position+1,steps-1,arrLen)
return stay + right
else:
stay = helper(position,steps-1,arrLen)
right = helper(position+1,steps-1,arrLen)
left = helper(position-1,steps-1,arrLen)
return stay + right + left
return helper(0,steps,arrLen-1) % (10 ** 9 + 7)
``` | 1 | 0 | ['Recursion', 'Memoization', 'Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Faster than 100% - Easy to understand memoization solution | faster-than-100-easy-to-understand-memoi-ti65 | Complexity\n- Time complexity: O(s * min(s, len)) \n Add your time complexity here, e.g. O(n) \n\n- Space complexity: O(s * min(s, len)) \n Add your space comp | trar | NORMAL | 2024-11-01T06:43:16.900453+00:00 | 2024-11-01T06:43:16.900481+00:00 | 3 | false | # Complexity\n- Time complexity: $$ O(s * min(s, len)) $$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(s * min(s, len)) $$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```javascript []\n/**\n * @param {number} steps\n * @param {number} arrLen\n * @return {number}\n */\n\n// Thinking notes...\n // I need to perform certain operation at each interval\n // Either I can - keep still, move left, move right\n // Now I need to figure out in how many ways I can still be at index 0 after k steps\n // I can recursively try to exhaust my steps\n // At each step, I can do three operations\n // If at any point of time I move <0 or >len return 0 -> no possible way\n // If I exhausted all the steps but still not at index 0 -> no possible way\n // If I exhausted all the steps and I am still at index 0 -> return 1\n\nconst mod = 1e9+7;\nvar numWays = function(steps, arrLen) {\n const memo = new Array(steps+1).fill(null).map(() => new Array(Math.min(arrLen, steps+1)).fill(null));\n return helper(steps, arrLen, 0, memo);\n};\n\nfunction helper(steps, n, idx, memo) {\n if(idx === 0 && steps === 0) return 1;\n if(idx < 0 || idx === n || steps === 0) return 0;\n if(memo[steps][idx] !== null) return memo[steps][idx]; \n let waysWithLeftMove = helper(steps-1, n, idx-1, memo);\n let waysWithRightMove = helper(steps-1, n, idx+1, memo);\n let waysWithNoMove = helper(steps-1, n, idx, memo);\n const totalWays = (waysWithLeftMove + waysWithRightMove + waysWithNoMove)%mod;\n memo[steps][idx] = totalWays;\n return totalWays;\n}\n``` | 1 | 0 | ['JavaScript'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Easy C++ Solution || Dynamic Programming | easy-c-solution-dynamic-programming-by-n-cyva | \n\n# Code\ncpp []\nclass Solution {\npublic:\n const int mod=1e9+7;\n vector<vector<int>>dp;\n int numWays(int steps, int arrLen) {\n dp.resize | NehaGupta_09 | NORMAL | 2024-09-01T14:01:39.676008+00:00 | 2024-09-01T14:01:39.676045+00:00 | 4 | false | \n\n# Code\n```cpp []\nclass Solution {\npublic:\n const int mod=1e9+7;\n vector<vector<int>>dp;\n int numWays(int steps, int arrLen) {\n dp.resize(steps+1,vector<int>(steps+1,-1));\n return fun(steps,0,arrLen)%mod;\n }\n int fun(int steps,int pos,int &arrLen)\n {\n if(steps==0 and pos==0)\n {\n return 1;\n }\n if(steps==0)\n {\n return 0;\n }\n if(dp[steps][pos]!=-1)\n {\n return dp[steps][pos]%mod;\n }\n int right=0,left=0,stay=0;\n if(pos<arrLen-1)\n right=fun(steps-1,pos+1,arrLen)%mod;\n if(pos>0)\n left=fun(steps-1,pos-1,arrLen)%mod;\n stay=fun(steps-1,pos,arrLen)%mod;\n return dp[steps][pos]=(0LL+(right%mod)+(left%mod)+(stay%mod))%mod;\n }\n};\n``` | 1 | 0 | ['Dynamic Programming', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Easy Java Solution || Dynamic Programming | easy-java-solution-dynamic-programming-b-8fx8 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | ravikumar50 | NORMAL | 2024-06-21T11:50:54.342473+00:00 | 2024-06-21T11:50:54.342503+00:00 | 11 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n\n static long dp[][];\n static long mod = (long)(1e9)+7;\n static long helper(int steps, int n, int pos){\n if(steps==0){\n if(pos==0) return 1;\n else return 0;\n }\n\n if(dp[steps][pos]!=-1) return dp[steps][pos]%mod;\n\n long a = (pos-1>=0) ? helper(steps-1,n,pos-1)%mod : 0;\n long b = (pos+1<n) ? helper(steps-1,n,pos+1)%mod : 0;\n long c = helper(steps-1,n,pos)%mod;\n\n return dp[steps][pos] = (a%mod+b%mod+c%mod)%mod;\n }\n public int numWays(int steps, int arrLen) {\n dp = new long[505][505];\n for(var a : dp) Arrays.fill(a,-1);\n return (int)(helper(steps,arrLen,0)%mod);\n }\n}\n``` | 1 | 0 | ['Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Dynamic Programming with hashmap,Unique Solution | dynamic-programming-with-hashmapunique-s-y2d6 | Basically here we are using HashMap as a dp table\n\nrest of the logic remians the same\n\nTO PICK, OR NOT TO PICK\n\n\n# Code\n\n/**\n * @param {number} steps\ | AbhayDutt | NORMAL | 2023-10-21T00:18:57.190509+00:00 | 2023-10-21T00:18:57.190529+00:00 | 1 | false | Basically here we are using HashMap as a dp table\n\nrest of the logic remians the same\n\nTO PICK, OR NOT TO PICK\n\n\n# Code\n```\n/**\n * @param {number} steps\n * @param {number} arrLen\n * @return {number}\n */\n// var numWays = function(steps, arrLen) {\n \n// };\n\n//logic\nvar numWays = function (steps, arrLen) {\n hm = new Map();\n return util1(steps, arrLen, 0);\n};\n\nlet hm;\nlet mod = 1000000007;\n\nlet util1 = function (steps, arrLen, currPos) {\n if (currPos < 0 || currPos >= arrLen) {\n return 0;\n }\n if (steps == 0) {\n if (currPos == 0) {\n return 1;\n } else {\n return 0;\n }\n }\n\n let key = steps + "-" + currPos;\n if (hm.has(key)) {\n return hm.get(key);\n }\n let ans = util1(steps - 1, arrLen, currPos);\n ans = (ans + util1(steps - 1, arrLen, currPos + 1)) % mod;\n ans = (ans + util1(steps - 1, arrLen, currPos - 1)) % mod;\n hm.set(key, ans);\n return ans;\n};\n\n\n```\nyou can check out my github repository where i am uploading famous interview questions topic wise with solutions.\nlink-- https://github.com/Abhaydutt2003/DataStructureAndAlgoPractice \nkindly upvote if you like my solution. you can ask doubts below.\xAF\n | 1 | 0 | ['Hash Table', 'Dynamic Programming', 'JavaScript'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++,Beats 85%time complexity,recursion+memoization,easy to understand | cbeats-85time-complexityrecursionmemoiza-titu | Intuition\nSo,here the questions says, where we can roll back to 0th idnex after moving one step forward,backward, or stay . since the maximum value of steps gi | robink2404 | NORMAL | 2023-10-20T01:59:52.380352+00:00 | 2023-10-20T01:59:52.380393+00:00 | 10 | false | # Intuition\nSo,here the questions says, where we can roll back to 0th idnex after moving one step forward,backward, or stay . since the maximum value of steps given in limits is 500 then the arrlen above 501 will be irrelevant as we if go there we would nevr=er had enough steps to return; so reduces size of arrlen to 501; now similarly if index in which we are currently present is greater then than steps then not possible to return as we would not have enough steps to return back.\nand if idx goes below 0 then it is noit possible to return so return 0; inorder to avoid repatation we would memoize it and reduce time complexity .\n# Approach\ntook 2D dp array of size 501*501.one to store index in which we currently present and one for steps remaining. if arrlen greatwr than 501 then reduce it to 501 as greater than that idx not possilblke to reach bavck to 0. then started recursion keeping v=bounfdary conditions oin mind and return answer with proper doing mod operations.\n\n# Complexity\n- Time complexity:\nO(stepos*steps)\n\nO(stepos*steps)\n\n# Code\n```\nclass Solution {\npublic:\nlong long unsigned int dp[501][501];\nint mod=1e9+7;\nlong long unsigned int solve(int steps,int arrlen,int idx)\n{\n if(steps==0)\n {\n if(idx==0)\n return 1;\n\n return 0;\n }\n if(idx>steps||idx>=arrlen||idx<0)\n return 0;\n if(dp[idx][steps]!=-1)\n return dp[idx][steps];\n\n return dp[idx][steps]=(solve(steps-1,arrlen,idx+1)%mod+solve(steps-1,arrlen,idx)%mod+solve(steps-1,arrlen,idx-1)%mod)%mod;\n\n\n}\n int numWays(int steps, int arrLen)\n {\n memset(dp,-1,sizeof(dp));\n if(arrLen>501)\n arrLen=501;\n return solve(steps,arrLen,0)%mod;\n\n }\n\n \n \n};\n``` | 1 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | [C++] Iterative DP Solution, 100% Time (0ms), ~92% Space (6.61MB) | c-iterative-dp-solution-100-time-0ms-92-ye6i1 | This problem can be solved thinking that each time, each position in the array we are going to consider can be reached in up to three ways:\n moving from the pr | Ajna2 | NORMAL | 2023-10-16T23:20:33.762393+00:00 | 2023-10-16T23:20:33.762424+00:00 | 3 | false | This problem can be solved thinking that each time, each position in the array we are going to consider can be reached in up to three ways:\n* moving from the previous position going `right`;\n* staying the previous position with `stay`;\n* moving from the follwing position going `left`.\n\nFor example, if at some point we had this situation:\n\n```cpp\n// positions:\n... a b c d e ...\n// ways to move there\n... 4 5 6 7 8 ...\n```\n\nWe can compute that we have `15` ways to reach `b`, summing:\n* all the `4` previous ways to reach `a` moving `right`;\n* all the `5` previous ways to reach `b` `stay`ing there;\n* all the `6` previous ways to reach `c` moving `left`.\n\nIf we repeat this whole process `steps` time, we can just get the final value in the first cell as our solution.\n\nNow, to code all of this, with `modVal` storing the requirement limit for each result, we will first of all rule out the edge case with `len == 1`, in which case we can only `stay`, so we will `return` `1`.\n\nWe can now declare our support variables next:\n* `last` and `penultimate` will be the pointers to our last and penultimate elements, respectively set to be `len - 1` and `last - 1`;\n* `dp` and `tmp` will be the pointers to the arrays we will use to compute the result.\n\nWe will initialise those arrays next, declaring each one of them as an array of `len` cells of type `long` and filling all the cells in `dp` with `0` (we cannot reach any of them yet), but the first that will have a value of `1` (there is one way to reach it initially, which is to just `stay` where we are starting from). \n\nWe will then loop `steps` time and:\n* compute the value of the border cell `tmp[0]` as the sum of the two cells above it (ie: `dp[0]` and `dp[1]`);\n* check if this value exceeds `modVal` and in case reduce it accordingly.\n* for each central cell `i` from index `1` to index `last` (escluded), we will:\n * compute the value of the border cell `tmp[i]` as the sum of the three cells above it (ie: `dp[i - 1]`, `dp[i]` and `dp[i + 1]`);\n * check if this value exceeds `modVal` and in case reduce it accordingly.\n* compute the value of the border cell `tmp[last]` as the sum of the two cells above it (ie: `dp[penultimate]` and `dp[last]`);\n* check if this value exceeds `modVal` and in case reduce it accordingly.\n* prepare for the next loop, by `swap`ping `dp` and `tmp` (no need to reset the latter, since we will just overwrite each cell there).\n\nNotice that in order to have all the values `< modVal` we are just looping subtracting it, since we are never going to ever get any value `> modVal * 2`, by summing at most `3` values which are below that threshold and considering that a substraction is significantly cheaper than a `%` operation.\n\nFinally, we will `return` the value of `dp[0]` :)\n\n# Complexity\n- Time complexity: $$O(steps * len)$$\n- Space complexity: $$O(len)$$\n\n# Code\n```cpp\nconstexpr long modVal = 1000000007;\n\nclass Solution {\npublic:\n int numWays(int steps, int len) {\n // edge case\n if (len == 1) return 1;\n // support variables\n int last = len - 1, penultimate = last - 1;\n long *dp, *tmp;\n // preparing dp and tmp\n dp = new long[len], tmp = new long[len];\n dp[0] = 1;\n memset(dp + 1, 0, (len - 1) * sizeof(long));\n // populating dp\n while (steps--) {\n // updating each cell with the some of the one above and the adjacent ones\n tmp[0] = dp[0] + dp[1];\n while (tmp[0] > modVal) tmp[0] -= modVal;\n for (int i = 1; i < last; i++) {\n tmp[i] = dp[i - 1] + dp[i] + dp[i + 1];\n while (tmp[i] > modVal) tmp[i] -= modVal;\n }\n tmp[last] = dp[penultimate] + dp[last];\n while (tmp[last] > modVal) tmp[last] -= modVal;\n swap(dp, tmp);\n }\n return dp[0];\n }\n};\n```\nThis solution was rather slow, but then I realised we do not really have to go populating `tmp` each time doing up to one million steps - we will never reach any position further than `steps`, so, right after the edge case, I added a condition to limit `len` to the minimum between its value and `step`, giving us a massive ~750X speed up time, probably the best I had so far, going from ~2300ms to only 3!\n\n# Complexity\n- Time complexity: $$O(steps * min(steps, len))$$\n- Space complexity: $$O(min(step, len))$$\n\n# Code\n```cpp\nconstexpr long modVal = 1000000007;\n\nclass Solution {\npublic:\n int numWays(int steps, int len) {\n // edge case\n if (len == 1) return 1;\n len = min(steps, len);\n // support variables\n int last = len - 1, penultimate = last - 1;\n long *dp, *tmp;\n // preparing dp and tmp\n dp = new long[len], tmp = new long[len];\n dp[0] = 1;\n memset(dp + 1, 0, (len - 1) * sizeof(long));\n // populating dp\n while (steps--) {\n // updating each cell with the some of the one above and the adjacent ones\n tmp[0] = dp[0] + dp[1];\n while (tmp[0] > modVal) tmp[0] -= modVal;\n for (int i = 1; i < last; i++) {\n tmp[i] = dp[i - 1] + dp[i] + dp[i + 1];\n while (tmp[i] > modVal) tmp[i] -= modVal;\n }\n tmp[last] = dp[penultimate] + dp[last];\n while (tmp[last] > modVal) tmp[last] -= modVal;\n swap(dp, tmp);\n }\n return dp[0];\n }\n};\n```\n\nI managed to squeeze out the last ms of performance by iterating only the first `dist` cells at each iteration, with `dist` being the minimum between the current `step` and `len`:\n\n# Complexity\n- Time complexity: $$O(steps * min(steps, len))$$\n- Space complexity: $$O(min(step, len))$$\n\n# Code\n```cpp\nconstexpr long modVal = 1000000007;\n\nclass Solution {\npublic:\n int numWays(int steps, int len) {\n // edge case\n if (len == 1) return 1;\n len = min(steps, len) + 1;\n // support variables\n long *dp, *tmp;\n // preparing dp and tmp\n dp = new long[len], tmp = new long[len];\n dp[0] = 1;\n memset(dp + 1, 0, (len - 1) * sizeof(long));\n memset(tmp, 0, len * sizeof(long));\n // populating dp\n len--, steps++;\n for (int dist, step = 1; step <= steps; step++) {\n dist = min(step, len);\n // updating each cell with the some of the one above and the adjacent ones\n tmp[0] = dp[0] + dp[1];\n while (tmp[0] > modVal) tmp[0] -= modVal;\n for (int i = 1; i < dist; i++) {\n tmp[i] = dp[i - 1] + dp[i] + dp[i + 1];\n while (tmp[i] > modVal) tmp[i] -= modVal;\n }\n swap(dp, tmp);\n }\n return dp[0];\n }\n};\n```\n\n# Brag\n\n | 1 | 0 | ['Array', 'Dynamic Programming', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 🔥C++ Easy & Efficient approach || Dynamic Programming || Time & Space Complexity are linear 🔥 | c-easy-efficient-approach-dynamic-progra-b4es | \n Describe your first thoughts on how to solve this problem. \n\n# Approach\nThe following algorithm is used to calculate the number of ways to reach the top o | vishukumar | NORMAL | 2023-10-15T20:54:09.616038+00:00 | 2023-10-15T20:54:09.616064+00:00 | 8 | false | \n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\nThe following algorithm is used to calculate the number of ways to reach the top of the staircase:\n1. Define a modulo constant to prevent integer overflow.\n2. Calculate the maximum possible position on the staircase that can be reached.\n3. Initialize an array to store the number of ways to reach each position on the staircase.\n4. Set the base case: There is one way to stay at the initial position.\n\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: O(n) \n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(n)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int MOD = 1e9 + 7;\n int step(int steps,int arrLen,int i,vector<vector<int>> &dp){\n // If position pointer is at the 0th position after all steps has been used and become 0.\n if(i==0 && steps==0) return 1;\n\n //If steps and position pointer are negative int that case we can return 0.\n //If position pointer is moving right and reached at last position of the array than in that case can return 0. \n if(steps<0 || i>=arrLen || i<0) return 0;\n\n if(dp[steps][i]!=-1) return dp[steps][i];\n\n //Now we can calculate all possibilities of the particular positions for example at single position we have 3 choices like stay, right and left.\n long long right=step(steps-1,arrLen,i+1,dp) % MOD;\n long long left=step(steps-1,arrLen,i-1,dp) % MOD;\n long long stay=step(steps-1,arrLen,i,dp) % MOD;\n\n dp[steps][i]=(left+right+stay) % MOD;\n return dp[steps][i];\n }\n int numWays(int steps, int arrLen) {\n // This condition is because if we have arrLen more than steps that its no use because maximum we can move our position pointer to the maximum steps.\n if(arrLen > steps) arrLen = steps;\n vector<vector<int>> dp(steps+1,vector<int>(arrLen+1,-1));\n return step(steps,arrLen,0,dp);\n }\n};\n``` | 1 | 0 | ['C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅ [Solution][Swift] Dynamic Programming | solutionswift-dynamic-programming-by-ada-k69x | TC: O(arrlen * steps)\nSC: O(arrlen * steps)\n\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\n let modulo = 1_000_000_000 + 7 | adanilyak | NORMAL | 2023-10-15T18:03:23.160176+00:00 | 2023-10-15T18:03:23.160199+00:00 | 4 | false | **TC:** $$O(arrlen * steps)$$\n**SC:** $$O(arrlen * steps)$$\n```\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\n let modulo = 1_000_000_000 + 7\n var memo = [String: Int]()\n func rec(_ i: Int, _ remain: Int) -> Int {\n guard remain > 0 else { return i == 0 ? 1 : 0 }\n guard i >= 0 else { return 0 }\n guard i < arrLen else { return 0 }\n let key = "\\(i),\\(remain)"\n guard memo[key] == nil else { return memo[key]! }\n memo[key] = (rec(i, remain - 1) % modulo\n + rec(i - 1, remain - 1) % modulo\n + rec(i + 1, remain - 1) % modulo) % modulo\n return memo[key]!\n }\n return rec(0, steps)\n }\n}\n``` | 1 | 0 | ['Dynamic Programming', 'Swift'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 🔥 Easy solution | Python 3 🔥| | easy-solution-python-3-by-arbazkhanpatha-4ta1 | Intuition\nNumber of Ways to Stay in the Same Place After Some Steps\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n1. Initialize | arbazkhanpathan0348 | NORMAL | 2023-10-15T17:54:43.726626+00:00 | 2023-10-15T17:54:43.726643+00:00 | 7 | false | # Intuition\nNumber of Ways to Stay in the Same Place After Some Steps\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n1. Initialize constants and variables:\n\n 1. MOD is set to 10^9 + 7, which is used for taking the modulus of the result to avoid integer overflow.\n 1. Calculate maxPosition as the minimum of arrLen - 1 and steps // 2. This is because you can only move arrLen - 1 steps at most.\n1. Create a 2D list dp of size (steps + 1) x (maxPosition + 1). dp[i][j] represents the number of ways to reach position j after i steps.\n\n1. Initialize dp[0][0] to 1 since there\'s one way to be at position 0 after 0 steps.\n\n1. Use a nested loop to iterate through each step from 1 to steps and each position from 0 to maxPosition.\n\n1. Update dp[i][j] as follows:\n\n 1. Set dp[i][j] to dp[i - 1][j], which represents staying in the same position (not moving).\n 1. If j > 0, add dp[i - 1][j - 1] to dp[i][j], which represents moving one step to the left.\n 1. If j < maxPosition, add dp[i - 1][j + 1] to dp[i][j], which represents moving one step to the right.\n 1. Take the modulus MOD of each addition to prevent overflow.\n1. After the loops, the final result is stored in dp[steps][0], which represents the number of ways to reach position 0 after steps steps.\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: $$O(n^2)$$\n<!-- Add your time complexity her e, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(n^2)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n MOD = 10**9 + 7\n maxPosition = min(arrLen - 1, steps // 2)\n dp = [[0] * (maxPosition + 1) for _ in range(steps + 1)]\n dp[0][0] = 1\n\n for i in range(1, steps + 1):\n for j in range(maxPosition + 1):\n dp[i][j] = dp[i - 1][j]\n if j > 0:\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % MOD\n if j < maxPosition:\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % MOD\n\n return dp[steps][0]\n \n``` | 1 | 0 | ['Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Fast Java Solutions: Optimized Bottom-up DP and Top-Down DP solution provided, Beats 96% | fast-java-solutions-optimized-bottom-up-dts9m | Provide Both Optimized Bottom-up DP and Top-Down DP solutions\n\n\n\n# Code\n\nclass Solution {\n int modulo = (int)Math.pow(10, 9) + 7;\n public int numW | wenyuoy0306 | NORMAL | 2023-10-15T17:42:03.325778+00:00 | 2023-10-15T17:42:03.325808+00:00 | 20 | false | Provide Both Optimized Bottom-up DP and Top-Down DP solutions\n\n\n\n# Code\n```\nclass Solution {\n int modulo = (int)Math.pow(10, 9) + 7;\n public int numWays(int steps, int arrLen) {\n arrLen = Math.min(steps / 2 + 1, arrLen);\n\n //Bottom-up DP\n int[] memo = new int[arrLen];\n memo[0] = 1;\n\n for (int i = steps - 1; i >= 0; i--) {\n int[] newMemo = new int[arrLen];\n for (int j = arrLen - 1; j >= 0; j--) {\n int left = j - 1 < 0? 0 : memo[j-1];\n int right = j + 1 >= arrLen? 0 : memo[j+1];\n newMemo[j] = ((left + right) % modulo + memo[j]) % modulo;\n }\n memo = newMemo;\n }\n\n return memo[0];\n\n // Integer[][] memo = new Integer[steps + 1][arrLen];\n // return getWays(0, 0, steps, arrLen, memo);\n }\n\n //Top-Down DP : backtracking with memoization\n private int getWays(int curStep, int curIndex, int steps, int arrLen, Integer[][] memo) {\n if (curStep == steps) {\n return curIndex == 0? 1 : 0;\n }\n\n if (memo[curStep][curIndex] != null) {\n return memo[curStep][curIndex];\n }\n\n int goLeft = curIndex - 1 >= 0? getWays(curStep + 1, curIndex - 1, steps, arrLen, memo): 0;\n int goRight = curIndex + 1 < arrLen? getWays(curStep + 1, curIndex + 1, steps, arrLen, memo) : 0;\n int stay = getWays(curStep + 1, curIndex, steps, arrLen, memo);\n\n return memo[curStep][curIndex] = ((goLeft + goRight) % modulo + stay) % modulo;\n\n } \n}\n``` | 1 | 0 | ['Dynamic Programming', 'Backtracking', 'Memoization', 'Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Ruby || DP | ruby-dp-by-alecn2002-ehck | \n# Code\nruby\nMOD = 10**9 + 7\n\nclass Numeric\n def min(v) = (self > v ? v : self)\nend\n\ndef num_ways(steps, arr_len)\n max_pos = (steps / 2).min(arr | alecn2002 | NORMAL | 2023-10-15T15:03:19.184579+00:00 | 2023-10-15T15:03:19.184604+00:00 | 5 | false | \n# Code\n```ruby\nMOD = 10**9 + 7\n\nclass Numeric\n def min(v) = (self > v ? v : self)\nend\n\ndef num_ways(steps, arr_len)\n max_pos = (steps / 2).min(arr_len - 1)\n (dp = Array.new(max_pos + 3, 0))[1] = 1\n steps.times.inject(dp) {|dp, i|\n [0] + dp.each_cons(3).collect {|c| c.sum % MOD } + [0]\n }[1]\nend\n``` | 1 | 0 | ['Ruby'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | ✅Accepted Java Code || Beats 80% | accepted-java-code-beats-80-by-thilaknv-ted5 | Complexity\n- Time complexity : O(m * n)\n Add your time complexity here, e.g. O(n) \n\n- Space complexity : O(m * n)\n Add your space complexity here, e.g. O(n | thilaknv | NORMAL | 2023-10-15T14:58:43.720120+00:00 | 2023-10-15T14:58:43.720137+00:00 | 7 | false | # Complexity\n- Time complexity : $$O(m * n)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity : $$O(m * n)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```JAVA []\nclass Solution {\npublic int numWays(int steps, int arr) {\n if(steps == 1 || arr == 1)\n return 1;\n arr = Math.min(steps / 2 + 1, arr) - 1;\n int[][] dp = new int[steps + 1][arr + 1];\n dp[0][0] = 1;\n int mod = 1000000007;\n for(int i = 1; i < steps; i++){\n for(int j = 0; j <= arr; j++){\n dp[i][j] = dp[i - 1][j];\n if(j > 0)\n dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;\n if(j < arr)\n dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % mod;\n }\n }\n return (dp[steps - 1][0] + dp[steps - 1][1]) % mod;\n}\n}\n```\n>>> ## Upvote\uD83D\uDC4D if you find helpful\n | 1 | 0 | ['Array', 'Dynamic Programming', 'Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C++ DP solution memoization... | c-dp-solution-memoization-by-kunalagra19-vd0y | \n\n# Code\n\nclass Solution {\npublic:\n const int mod=1e9+7;\n int dp[501][501];\n int helper(int steps,int len,int arrlen)\n {\n if(len==0 | kunalagra197 | NORMAL | 2023-10-15T14:29:11.155042+00:00 | 2023-10-15T14:29:11.155071+00:00 | 55 | false | \n\n# Code\n```\nclass Solution {\npublic:\n const int mod=1e9+7;\n int dp[501][501];\n int helper(int steps,int len,int arrlen)\n {\n if(len==0 && steps==0)return 1;\n if(len<0 || len==arrlen || steps<0)return 0;\n if(len>steps)return 0;\n if(dp[len][steps]!=-1)return dp[len][steps];\n int ways=0;\n for(int x=-1;x<=1;x++)\n {\n ways=(ways+helper(steps-1,len+x,arrlen))%mod;\n }\n return dp[len][steps]=ways;\n }\n\n int numWays(int steps, int arrLen) {\n memset(dp,-1,sizeof(dp));\n return helper(steps,0,arrLen);\n }\n};\n``` | 1 | 0 | ['Dynamic Programming', 'Memoization', 'C++'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | My java easy recursive 5ms solution 99% faster | my-java-easy-recursive-5ms-solution-99-f-z8dd | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | raghavrathore7415 | NORMAL | 2023-10-15T13:47:38.558296+00:00 | 2023-10-15T14:24:39.979766+00:00 | 28 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n int mod = (int) 1e9 + 7;\n public int numWays(int steps, int arrLen) {\n return getNum(0, steps, Math.min(steps, arrLen), new Integer[steps + 1][steps + 1]);\n }\n\n public int getNum(int idx, int s, int len, Integer[][] cache){\n if(idx < 0 || idx == len){\n return 0;\n }\n if(idx == 0 && s == 0){\n return 1;\n }\n if(s == 0 || s - idx < 0){\n return 0;\n }\n if(cache[idx][s] != null){\n return cache[idx][s];\n }\n int res = getNum(idx, s - 1, len, cache);\n res += getNum(idx + 1, s - 1, len, cache);\n res %= mod;\n res += getNum(idx - 1, s - 1, len, cache);\n res %= mod;\n cache[idx][s] = res;\n return res;\n }\n}\n``` | 1 | 0 | ['Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | How to overcome Memory Limit Exceed (MLE)?, here is the solution to fix this! (C++) | how-to-overcome-memory-limit-exceed-mle-j4gij | Intuition\n We will use recursion to find out the number of ways.\n Describe your first thoughts on how to solve this problem. \n\n# Why MLE\n1. If you are m | geeteshyadav | NORMAL | 2023-10-15T12:57:04.889497+00:00 | 2023-10-15T12:57:04.889528+00:00 | 26 | false | # Intuition\n We will use recursion to find out the number of ways.\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Why MLE\n1. If you are making dp array like **dp[arrLen][steps + 1]**, then its definitely going to give MLE **( 10^6 * 501)** and it is something about 10^9. \n2. But we can smartly optimize the space needed , lets take one example. If we had arrLen = 10 and steps = 3.\n3. It means that we have 10 spaces : _ _ _ _ _ _ _ _ _ _ and we can take only 3 steps and not more than 3. So if i am standing at index 0 so i can go 3 steps to the right at max , so we only need **min(arrLen , step)** size to store that. \n4. So we can make dp array like this : **dp[min(arrLen , steps)][steps +1];**\n# Code\n```\nclass Solution {\npublic:\n int mod = 1e9 + 7;\n int fun(int idx, int steps , int n , vector<vector<int>> &dp){\n if(idx < 0 || idx >= n){\n return 0;\n }\n if(steps == 0){\n if(idx == 0){\n return 1;\n }else return 0;\n }\n if(dp[idx][steps] != -1){\n return dp[idx][steps];\n }\n int left = fun(idx -1, steps -1, n , dp);\n int same = fun(idx , steps - 1, n , dp);\n int right = fun(idx + 1 , steps - 1 , n ,dp);\n return dp[idx][steps] = ( (left%mod + right%mod) % mod + same%mod) % mod;\n }\n int numWays(int steps, int arrLen) {\n int n = min(steps, arrLen);\n vector<vector<int>> dp(n, vector<int>(steps + 1,-1));\n return fun(0 , steps , arrLen,dp);\n }\n};\n``` | 1 | 0 | ['Divide and Conquer', 'Dynamic Programming', 'Recursion', 'Memoization', 'C++'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | C# Solution ; | c-solution-by-moderneinstein-0erz | Intuition\n Describe your first thoughts on how to solve this problem. \n- At each point during the algorithm , there are multiple paths of\n- computation to c | ModernEinstein_ | NORMAL | 2023-10-15T12:41:55.536589+00:00 | 2023-10-15T12:41:55.536609+00:00 | 10 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. --> \n- At each point during the algorithm , there are multiple paths of\n- computation to consider, \n-Dynamic programmming may be used for this situation ; \n-At each phase of the algorithm , consider the number of \n-of ways to stay the same if the pointer moves foward,backward,\nor stays the same the current step , \n-If the number of steps have been exhausted, return 1 if the pointer has shifted by 0 moves,else return 0 ;\n# Approach\n<!-- Describe your approach to solving the problem. -->\n- Dynamic programming approach for this scenario ; \n- Create a 2D array to store number of ways from each position \n- within the array with each number of steps remaining ; \n- use the following recurrence statements to resolve the number of \n- ways with the number of steps left , at the current position , \n- long delta = 0 ; \n- for(int vs=-1;vs<=1;vs++){\n delta+=resolve(post+1,shift+vs,crest,spans) ; } \n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n<!-- O(N^2) -->\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n-O(S^2) ; \n-S is the number of steps to be evaluted ; \n-It is difficult to exceed any position in the array \n-if it is greater than the number of steps to consider ; \n# Code\n```\nusing System.Text ; \nusing System.Linq ;\nusing System.Collections ; \n\npublic class Solution { \n public static long[][] cases ; \n public static int MODULO = (int)Math.Pow (10,9)+7 ; \n public static bool configured = false ; \n public static int REACH = 550 ; \n public static long resolve(int post,int shift,int crest,int spans){\n if(post>=crest){\n if(shift==0){return 1 ; }\n return 0 ; } \n if(shift<0){return 0 ; } \n if(shift>=spans){return 0 ; }\n if(cases[post][shift]!=-2l){return cases[post][shift] ; } \n long delta = 0 ; \n for(int vs=-1;vs<=1;vs++){\n delta+=resolve(post+1,shift+vs,crest,spans) ; } \n delta = delta%MODULO ; \n cases[post][shift] = delta ; \n return delta ; \n } \n // if(configured ==false){ \n // configured = true ; \n // } \n public int NumWays(int steps, int arrLen) {\n cases = new long[REACH][] ; \n for (int bt =0;bt<REACH;bt++){\n cases[bt] = new long[REACH+2] ; \n for(int nt=0;nt<REACH;nt++){cases[bt][nt]= -2l ; } }\n long value = resolve(0,0,steps, arrLen) ; \n value = value % MODULO ; \n return (int) value ; \n \n }\n}\n``` | 1 | 0 | ['C#'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | 1269. Number of Ways to Stay in the Same Place After Some Steps || Java | 1269-number-of-ways-to-stay-in-the-same-ifhb0 | \nclass Solution {\n int mod = (int)(1e9+7); // Define a constant for modulo operation\n HashMap<String, Integer> hp = new HashMap<String, Integer>(); / | ArpAry | NORMAL | 2023-10-15T12:40:07.607950+00:00 | 2023-10-15T12:40:07.607973+00:00 | 1 | false | ```\nclass Solution {\n int mod = (int)(1e9+7); // Define a constant for modulo operation\n HashMap<String, Integer> hp = new HashMap<String, Integer>(); // Create a HashMap for memoization\n\n // Recursive function to calculate the number of ways to reach a position\n public int solve(int steps, int arrLen, int curstep, int ind) {\n // Base case: If we reach the target position with the specified number of steps, return 1.\n if (ind == 0 && steps == curstep)\n return 1;\n\n // Base case: If the current number of steps exceeds the specified steps, return 0.\n if (curstep >= steps)\n return 0;\n\n String key = ind + " " + curstep; // Create a unique key based on the current position and step count\n\n // If the result for the current position and step count is already memoized, return it.\n if (hp.containsKey(key))\n return hp.get(key);\n\n int ans = 0;\n\n // Recursive calls to explore three possible moves (stay, move left, move right).\n ans += solve(steps, arrLen, curstep + 1, ind) % mod;\n ans = ans % mod;\n\n if (ind >= 1)\n ans += (solve(steps, arrLen, curstep + 1, ind - 1) % mod);\n\n ans = ans % mod;\n\n if (ind + 1 < arrLen)\n ans += (solve(steps, arrLen, curstep + 1, ind + 1) % mod);\n ans = ans % mod;\n\n hp.put(key, ans); // Memoize the result for the current position and step count.\n return ans; // Return the calculated result.\n }\n\n // Public method to initiate the solving process and return the final result.\n public int numWays(int steps, int arrLen) {\n return solve(steps, arrLen, 0, 0);\n }\n}\n``` | 1 | 0 | ['Memoization'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Catching the 'catch' || Java Solution | catching-the-catch-java-solution-by-rish-l6d9 | This problem is not very hard as the problem statement and the difficulty tag demostrates so. \nAnyone with a touch of dynamic programming practice would easily | Rishabh2804 | NORMAL | 2023-10-15T11:49:08.090363+00:00 | 2023-10-15T11:49:08.090383+00:00 | 8 | false | This problem is not very hard as the problem statement and the difficulty tag demostrates so. <br>\nAnyone with a touch of dynamic programming practice would easily think a straightforward solution, \nonly to find that the contrants are too high for a 2D dp. \n\n   `1 <= n <= 10^6`\n   `1 <= steps <= 500`\n \n Total space consumed would be -> `1 <= n * steps <= 5 * 10^9`\n \n But it only takes to find the hidden \'catch\' to solve the question.\n The constraints for `n` are basically out of use, as :\n \n\t\t\tSteps count : \n arr[i] --> arr[i + 1] == 1\n arr[i] <-- arr[i + 1] == 1\n \n => Thus, a complete round-about path \n arr[i] --> arr[j] \n takes 2 * (j - i) steps\n \n => For threshold limit of [MAX_STEPS] steps, \n furthest point reachable from index i is => i + MAX_STEPS / 2\n \n => For a given step count == STEPS, \n => From start point 0, furthest point reachable would be \n (0 + STEPS) ==> STEPS / 2\n \n => Maximum feasible length of array = (ei - si + 1) ==> STEPS / 2 + 1\n ==> effectiveSize = 1 + STEPS / 2\n\t\t \n\t\t => In worst case scenario, \n\t\t MAX_STEPS = 500 (given)\n\t\t\t\t MAX_EFFECTIVE_SIZE = 1 + MAX_STEPS / 2\n\t\t\t\t\t\t\t\t => 1 + 500 / 2 => 251\n\t\t\t\t\t\t\t\t\t\n\t\t\tA 2D array of size = 251 * 251 = 63001 = 6 * 10 ^4 is easily manageable\n\t\t\t\n<br>\n<b>Demonstration by a simple Java code: -</b>\n<br>\n\n```java\nclass Solution {\n \n private static final int MAX_STEPS = 500;\n static final int MOD = 1000000007;\n \n private static final int ADD(int num1, int num2){\n return ((num1 % MOD) + (num2 % MOD)) % MOD;\n }\n \n /** Approach 1 : Recursive (of course TLE \uD83D\uDE05)\n * Time Complexity --> O(3 ^ steps) \n * Space Complexity --> O(3 ^ steps) (Stack space)\n **/\n private int solve1(int i, int steps, int n){\n if(i < 0 || i >= n) return 0;\n \n if(steps <= 0) return (i == 0) ? 1 : 0;\n \n int stay = solve1(i, steps - 1, n);\n int left = solve1(i - 1, steps - 1, n);\n int right = solve1(i + 1, steps - 1, n);\n \n return ADD(stay, ADD(left, right));\n }\n \n /** Approach 2 : Memoization\n * Time Complexity --> O(n * steps) \n * Space Complexity --> O(n * steps) + O(steps) (Stack space)\n **/\n private int solve2(int i, int steps, int n, Integer[][] dp){\n if(i < 0 || i >= n) return 0;\n \n if(steps <= 0) return (i == 0) ? 1 : 0;\n \n if(dp[i][steps] != null) return dp[i][steps];\n \n int stay = solve2(i, steps - 1, n, dp);\n int left = solve2(i - 1, steps - 1, n, dp);\n int right = solve2(i + 1, steps - 1, n, dp);\n \n return dp[i][steps] = ADD(stay, ADD(left, right));\n }\n \n /** Approach 3 : Tabulation\n * Time Complexity --> O(n * steps) \n * Space Complexity --> O(n * steps)\n **/\n private int solve3(int n, int steps){\n int[][] dp = new int[steps + 1][n];\n dp[0][0] = 1;\n \n int left;\n int stay;\n int right;\n \n for(int step = 1; step <= steps; ++step){\n \n /** If we are currently at pos j,\n * we would require atleast \n * (j - i) steps to reach pos i\n *\n * => In other words, to return to pos from pos i\n * we need atleast i steps\n * \n * => Conversely, if we have `steps` number of steps,\n * farthest we can reach from index 0 is \n * (0 + steps) = steps\n * \n * This would reduce time & space complexity to half of original.\n **/\n \n int lim = Math.min(step, n - 1);\n for(int i = 0; i <= lim; ++i){ \n \n left = (i > 0) ? dp[step - 1][i - 1] : 0;\n stay = dp[step - 1][i];\n right = (i < n - 1) ? dp[step - 1][i + 1] : 0;\n \n dp[step][i] = ADD(stay, ADD(left, right));\n }\n }\n \n // Back to pos 0, after steps == `steps`\n return dp[steps][0];\n }\n \n public int numWays(int steps, int arrLen) {\n /**\n * Steps count : \n * arr[i] --> arr[i + 1] == 1\n * arr[i] <-- arr[i + 1] == 1\n * \n * => Thus, a complete round-about path \n * arr[i] --> arr[j] \n * takes 2 * (j - i) steps\n * \n * => For threshold limit of [MAX_STEPS] steps, \n * furthest point reachable from index i is => i + MAX_STEPS / 2\n *\n * => For a given step count == STEPS, \n * => From start point 0, furthest point reachable would be \n * (0 + STEPS) ==> STEPS / 2\n *\n * => Maximum feasible length of array = (ei - si + 1) ==> STEPS / 2 + 1\n * ==> effectiveSize = 1 + STEPS / 2\n **/\n int reachableLength = 1 + steps / 2;\n int n = Math.min(arrLen, reachableLength);\n \n // return solve1(0, steps, n);\n // return solve2(0, steps, n, new Integer[n][steps + 1]);\n return solve3(n, steps);\n }\n}\n``` | 1 | 0 | ['Dynamic Programming', 'Memoization', 'Java'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | plain 2d dp | plain-2d-dp-by-mr_stark-v9tg | \nclass Solution {\npublic:\n \n vector<vector<int>> dp;\n int mod = 1e9+7;\n int solve(int i,int s, int n)\n {\n if(i>=n || i<0)\n | mr_stark | NORMAL | 2023-10-15T11:34:39.208027+00:00 | 2023-10-15T11:34:39.208049+00:00 | 10 | false | ```\nclass Solution {\npublic:\n \n vector<vector<int>> dp;\n int mod = 1e9+7;\n int solve(int i,int s, int n)\n {\n if(i>=n || i<0)\n return 0;\n if(s == 0){\n return i == 0;\n }\n \n if(dp[i][s]!=-1)\n return dp[i][s];\n long long int c = solve(i,s-1,n)%mod;\n long long int a = solve(i+1,s-1,n)%mod;\n long long int b = solve(i-1,s-1,n)%mod;\n \n return dp[i][s] = (a+b+c)%mod;\n }\n \n int numWays(int s, int n) {\n n = min(n,s);\n dp.resize(500+1, vector<int>(500+1,-1));\n return solve(0,s,n);\n }\n};\n``` | 1 | 0 | ['C'] | 1 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | python | python-by-ski-p3r-fm53 | \nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n modulo = 1000000007\n max_len = min(arrLen, 1 + steps // 2)\n w | ski-p3r | NORMAL | 2023-10-15T11:33:01.710304+00:00 | 2023-10-15T11:33:01.710327+00:00 | 8 | false | ```\nclass Solution:\n def numWays(self, steps: int, arrLen: int) -> int:\n modulo = 1000000007\n max_len = min(arrLen, 1 + steps // 2)\n ways = [0] * (max_len + 1)\n ways[0] = 1\n for i in range(steps):\n left = 0\n for j in range(min(max_len, i + 2, steps - i + 3)):\n left, ways[j] = ways[j], (ways[j] + left + ways[j + 1]) % modulo\n return ways[0]\n``` | 1 | 0 | ['Python', 'Python3'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | very easy solution with dp | very-easy-solution-with-dp-by-teenuburi-idrc | \n\n# Complexity\n- Time complexity:\nO(nn)\n\n- Space complexity:\nO(nn)\n\n# Code\n\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\ | teenuburi | NORMAL | 2023-10-15T11:19:52.264021+00:00 | 2023-10-15T11:19:52.264037+00:00 | 7 | false | \n\n# Complexity\n- Time complexity:\nO(n*n)\n\n- Space complexity:\nO(n*n)\n\n# Code\n```\nclass Solution {\n func numWays(_ steps: Int, _ arrLen: Int) -> Int {\n var arrLen = min(steps, arrLen)\n\n var dp = [[Int]](repeating: [Int](repeating: -1, count: arrLen+2), count: steps+1)\n\n return numWays(steps, arrLen, 1, &dp)\n }\n func numWays(_ steps: Int, _ arrLen: Int, _ index: Int, _ dp: inout [[Int]]) -> Int {\n if index < 1 || index > arrLen {\n return 0\n } \n if steps == 0 && index == 1 {\n return 1\n } else if steps == 0 {\n return 0\n }\n\n if dp[steps-1][index-1] == -1 {\n dp[steps-1][index-1] = numWays(steps-1, arrLen, index-1, &dp)\n }\n\n if dp[steps-1][index+1] == -1 {\n dp[steps-1][index+1] = numWays(steps-1, arrLen, index+1, &dp)\n }\n if dp[steps-1][index] == -1 {\n dp[steps-1][index] = numWays(steps-1, arrLen, index, &dp)\n }\n return (dp[steps-1][index+1] + dp[steps-1][index-1] + dp[steps-1][index])%1000000007\n }\n}\n``` | 1 | 0 | ['Swift'] | 0 |
number-of-ways-to-stay-in-the-same-place-after-some-steps | Best Java Solution || Beats 95% | best-java-solution-beats-95-by-ravikumar-75o6 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | ravikumar50 | NORMAL | 2023-10-15T10:48:07.905441+00:00 | 2023-10-15T10:48:07.905459+00:00 | 30 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n\n // coppied as I haven\' t studied D.P yet\n public int numWays(int steps, int arrLen) {\n final int kMod = 1_000_000_007; \n final int n = Math.min(arrLen, steps / 2 + 1); \n long[] dp = new long[n]; \n dp[0] = 1; \n while (steps-- > 0) { \n long[] newDp = new long[n];\n for (int i = 0; i < n; ++i) { \n newDp[i] = dp[i]; \n if (i - 1 >= 0)\n newDp[i] += dp[i - 1]; \n if (i + 1 < n)\n newDp[i] += dp[i + 1]; \n newDp[i] %= kMod; \n }\n dp = newDp; \n }\n\n return (int) dp[0]; \n }\n}\n``` | 1 | 0 | ['Java'] | 0 |
get-maximum-in-generated-array | [Python] Simulate process, explained | python-simulate-process-explained-by-dba-dsh8 | In this problem you just need to do what is asked: if we have even and odd indexes, generate data in correct way. There is a couple of small tricks to make your | dbabichev | NORMAL | 2021-01-15T08:35:07.618844+00:00 | 2021-01-15T08:35:07.618872+00:00 | 5,951 | false | In this problem you just need to do what is asked: if we have even and odd indexes, generate data in correct way. There is a couple of small tricks to make your code cleaner:\n1. Create `nums = [0] * (n + 2)` to handle case `n = 0`.\n2. Use ` nums[i] = nums[i//2] + nums[(i//2)+1] * (i%2)` to handle both cases of even and odd indexes\n3. Finally, return maximum among first `n + 1` elements.\n\n**Complexity**: time and space complexity is `O(n)`.\n\n**Discussion** As it is with given solution problem just do not have any idea behind. I think there should be `O(log n)` solution, I am thinking about right now.\n\n```\nclass Solution:\n def getMaximumGenerated(self, n):\n nums = [0]*(n+2)\n nums[1] = 1\n for i in range(2, n+1):\n nums[i] = nums[i//2] + nums[(i//2)+1] * (i%2)\n \n return max(nums[:n+1])\n```\n\nIf you have any questions, feel free to ask. If you like solution and explanations, please **Upvote!** | 90 | 2 | [] | 10 |
get-maximum-in-generated-array | C++ Simple and Short Solution 0 ms faster than 100% | c-simple-and-short-solution-0-ms-faster-t2fd4 | \nclass Solution {\npublic:\n int getMaximumGenerated(int n) {\n if (n == 0 || n == 1) return n;\n \n vector<int> arr(n+1);\n arr | yehudisk | NORMAL | 2021-01-15T09:38:08.941986+00:00 | 2021-01-15T09:38:08.942012+00:00 | 7,478 | false | ```\nclass Solution {\npublic:\n int getMaximumGenerated(int n) {\n if (n == 0 || n == 1) return n;\n \n vector<int> arr(n+1);\n arr[0] = 0;\n arr[1] = 1;\n int maxi = 1;\n \n for (int i = 2; i <= n; i++) {\n arr[i] = i % 2 == 0 ? arr[i/2] : arr[i / 2] + arr[i / 2 + 1];\n maxi = max(maxi, arr[i]);\n }\n \n return maxi;\n }\n};\n```\n**Like it? please upvote...** | 55 | 2 | ['C'] | 6 |
get-maximum-in-generated-array | C++ Precompute + O(1) | c-precompute-o1-by-votrubac-28mn | We compute the function for 100 elements once. Then, we scan the array and record the maximum element so far.\n\nThis way, all further queries will requrie O(1) | votrubac | NORMAL | 2020-11-08T04:03:23.496618+00:00 | 2020-11-08T04:09:02.683040+00:00 | 3,253 | false | We compute the function for 100 elements once. Then, we scan the array and record the maximum element so far.\n\nThis way, all further queries will requrie O(1) lookup.\n\n```cpp\nint f[101] = { 0, 1, 0};\nclass Solution {\npublic:\n int getMaximumGenerated(int n) {\n if (f[2] == 0) {\n for (int i = 2; i <= 100; ++i)\n f[i] = i % 2 ? f[i / 2] + f[i / 2 + 1] : f[i / 2];\n for (int i = 2; i <= 100; ++i)\n f[i] = max(f[i], f[i - 1]);\n }\n return f[n];\n }\n};\n``` | 27 | 25 | [] | 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.