## Problem

**Problem ID**: 1398

**Title**: Number of Ways to Stay in the Same Place After Some Steps

**Difficulty**: Hard

**Description**:

You have a pointer at index `0`

in an array of size `arrLen`

. 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).

Given two integers `steps`

and `arrLen`

, return the number of ways such that your pointer still at index `0`

after **exactly** `steps`

steps. Since the answer may be too large, return it **modulo** `10`

.^{9} + 7

**Example 1:**

Input:steps = 3, arrLen = 2Output:4Explanation:There are 4 differents ways to stay at index 0 after 3 steps. Right, Left, Stay Stay, Right, Left Right, Stay, Left Stay, Stay, Stay

**Example 2:**

Input:steps = 2, arrLen = 4Output:2Explanation:There are 2 differents ways to stay at index 0 after 2 steps Right, Left Stay, Stay

**Example 3:**

Input:steps = 4, arrLen = 2Output:8

**Constraints:**

`1 <= steps <= 500`

`1 <= arrLen <= 10`

^{6}

## Thoughts

This problem is similar to 1155. Number of Dice Rolls With Target Sum
where the number of ways for event `i`

is dependent on event `i-1`

. However, after looking at the discuss
I learnt that presumably 2D DP problems that replies only on the previous state (`DP[i][j-1]`

) can be
simplified to 1D by storing 2 x 1D DP instead where one of the dp acts as the previous and the other
acts as the present. At the end of iteration you will just need to swap both the DP. This will allow
the memory complexity to reduce from O(N^2) to O(N)

## Solution

**General Idea**

DP state:

`prev_dp[i]`

: represent the ways to reach position`i`

at`k-1`

step from position 0`dp[i]`

: represent the ways to reach position`i`

at`k`

step from position 0

DP transition:

- Intuition: to reach position 0 at step
`k`

you will just need to enumerate over the possible kth step.- If the kth step is left, then the position at step
`k-1`

is`i+1`

. This can be easily extended to kth step being stay or right. - The total ways is to reach
`i`

is just the sum of the ways to reach`i-1,i,i+1`

at step`k-1`

- If the kth step is left, then the position at step
`dp[i] = prev_dp[i-1] + prev_dp[i] + prev_dp[i+1]`

at the end of the iteration`swap(dp, prev_dp)`

### Implementation

```
class Solution {
public:
int numWays(int steps, int arrLen) {
int size = min(arrLen, steps+2);
vector<int> prev_dp(size, 0);
vector<int> dp(size, 0);
prev_dp[0] = 1;
int mod = 1e9 + 7;
for (int k = 1; k <= steps; k++) {
for (int i = 0; i < size; i++) {
dp[i] = 0;
if (i > 0) dp[i] = (dp[i] + prev_dp[i-1]) % mod;
if (i < size - 1) dp[i] = (dp[i] + prev_dp[i+1]) % mod;
dp[i] = (dp[i] + prev_dp[i]) % mod;
}
swap(dp, prev_dp);
}
return prev_dp[0];
}
};
```