# Check if end of given Binary string can be reached by choosing jump value in between given range

Given two positive integers **L** and **R** and a binary string **S** of size **N**, the task is to check if the end of the string is reached from the index **0** by a series of jumps of indices, say **i** such that **S[i]** is **0** jumps are allowed in the range **[L, R]**. If it is possible to reach, then print **Yes**. Otherwise, print **No**.

**Examples:**

Input:S = “011010”, L = 2, R = 3Output:YesExplanation:

Following are the series of moves having characters at that indices as 0:

S[0](= 0) -> S[3](= 0) -> S[5](= 0) and S[5] is the end of the string S.

Therefore, print Yes.

Input:S = “01101110”, L = 2, R = 3Output:No

**Approach:** The above problem can be solved with the help of Dynamic Programming, the idea is to maintain **1D **array, say **dp[]** where** dp[i]** will store the possibility of reaching the i^{th} position and update each index accordingly. Below are the steps:

- Initialize an array,
**dp[]**such that**dp[i]**stores whether any index**i**can be reached from index**0**or not. Update the value of**dp[0]**as**1**as it is the current standing index. - Initialize a variable,
**pre**as**0**that stores the number of indices from which the current index is reachable. - Iterate over the range
**[1, N)**and update the value of**pre**variable as follows:- If the value of (
**i >= minJump**), then increment the value of**pre**by**dp[i – minJump]**. - If the value of (
**i > maxJump**), then decrement the value of**pre**by**dp[i – maxJump – 1]**.

- If the value of (
- If the value of
**pre**is positive, then**at least 1**index from which the current index is reachable. Therefore, update the value of**dp[i] = 1**, if the value of**S[i] = 0**. - After completing the above steps, if the value of
**dp[N – 1]**is positive, then print**Yes**. Otherwise, print**No**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if it is possible` `// to reach the end of the binary string` `// using the given jumps` `bool` `canReach(string s, ` `int` `L, ` `int` `R)` `{` ` ` `// Stores the DP states` ` ` `vector<` `int` `> dp(s.length());` ` ` `// Initial state` ` ` `dp[0] = 1;` ` ` `// Stores count of indices from which` ` ` `// it is possible to reach index i` ` ` `int` `pre = 0;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = 1; i < s.length(); i++) {` ` ` `// Update the values of pre` ` ` `// accordingly` ` ` `if` `(i >= L) {` ` ` `pre += dp[i - L];` ` ` `}` ` ` `// If the jump size is out of` ` ` `// the range [L, R]` ` ` `if` `(i > R) {` ` ` `pre -= dp[i - R - 1];` ` ` `}` ` ` `dp[i] = (pre > 0) and (s[i] == ` `'0'` `);` ` ` `}` ` ` `// Return answer` ` ` `return` `dp[s.length() - 1];` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"01101110"` `;` ` ` `int` `L = 2, R = 3;` ` ` `cout << (canReach(S, L, R) ? ` `"Yes"` `: ` `"No"` `);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `public` `class` `GFG {` ` ` ` ` `// Function to check if it is possible` ` ` `// to reach the end of the binary string` ` ` `// using the given jumps` ` ` `static` `int` `canReach(String s, ` `int` `L, ` `int` `R)` ` ` `{` ` ` ` ` `// Stores the DP states` ` ` `int` `dp[] = ` `new` `int` `[s.length()];` ` ` ` ` `// Initial state` ` ` `dp[` `0` `] = ` `1` `;` ` ` ` ` `// Stores count of indices from which` ` ` `// it is possible to reach index i` ` ` `int` `pre = ` `0` `;` ` ` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = ` `1` `; i < s.length(); i++) {` ` ` ` ` `// Update the values of pre` ` ` `// accordingly` ` ` `if` `(i >= L) {` ` ` `pre += dp[i - L];` ` ` `}` ` ` ` ` `// If the jump size is out of` ` ` `// the range [L, R]` ` ` `if` `(i > R) {` ` ` `pre -= dp[i - R - ` `1` `];` ` ` `}` ` ` ` ` `if` `(pre > ` `0` `&& s.charAt(i) == ` `'0'` `)` ` ` `dp[i] = ` `1` `;` ` ` `else` ` ` `dp[i] = ` `0` `;` ` ` `}` ` ` ` ` `// Return answer` ` ` `return` `dp[s.length() - ` `1` `];` ` ` `}` ` ` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `String S = ` `"01101110"` `;` ` ` `int` `L = ` `2` `, R = ` `3` `;` ` ` ` ` `if` `(canReach(S, L, R) == ` `1` `)` ` ` `System.out.println(` `"Yes"` `);` ` ` `else` ` ` `System.out.println(` `"No"` `);` ` ` `}` `}` `// This code is contributed by AnkThon` |

## Python3

`# python program for the above approach` `# Function to check if it is possible` `# to reach the end of the binary string` `# using the given jumps` `def` `canReach(s, L, R):` ` ` `# Stores the DP states` ` ` `dp ` `=` `[` `0` `for` `_ ` `in` `range` `(` `len` `(s))]` ` ` `# Initial state` ` ` `dp[` `0` `] ` `=` `1` ` ` `# Stores count of indices from which` ` ` `# it is possible to reach index i` ` ` `pre ` `=` `0` ` ` `# Traverse the given string` ` ` `for` `i ` `in` `range` `(` `1` `, ` `len` `(s)):` ` ` `# Update the values of pre` ` ` `# accordingly` ` ` `if` `(i >` `=` `L):` ` ` `pre ` `+` `=` `dp[i ` `-` `L]` ` ` `# If the jump size is out of` ` ` `# the range [L, R]` ` ` `if` `(i > R):` ` ` `pre ` `-` `=` `dp[i ` `-` `R ` `-` `1` `]` ` ` `dp[i] ` `=` `(pre > ` `0` `) ` `and` `(s[i] ` `=` `=` `'0'` `)` ` ` `# Return answer` ` ` `return` `dp[` `len` `(s) ` `-` `1` `]` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `S ` `=` `"01101110"` ` ` `L ` `=` `2` ` ` `R ` `=` `3` ` ` `if` `canReach(S, L, R):` ` ` `print` `(` `"Yes"` `)` ` ` `else` `:` ` ` `print` `(` `"No"` `)` ` ` `# This code is contributed by rakeshsahni` |

## C#

`// C# program for the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to check if it is possible` ` ` `// to reach the end of the binary string` ` ` `// using the given jumps` ` ` `static` `int` `canReach(String s, ` `int` `L, ` `int` `R)` ` ` `{` ` ` `// Stores the DP states` ` ` `int` `[] dp = ` `new` `int` `[s.Length];` ` ` `// Initial state` ` ` `dp[0] = 1;` ` ` `// Stores count of indices from which` ` ` `// it is possible to reach index i` ` ` `int` `pre = 0;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = 1; i < s.Length; i++)` ` ` `{` ` ` `// Update the values of pre` ` ` `// accordingly` ` ` `if` `(i >= L)` ` ` `{` ` ` `pre += dp[i - L];` ` ` `}` ` ` `// If the jump size is out of` ` ` `// the range [L, R]` ` ` `if` `(i > R)` ` ` `{` ` ` `pre -= dp[i - R - 1];` ` ` `}` ` ` `if` `(pre > 0 && s[i] == ` `'0'` `)` ` ` `dp[i] = 1;` ` ` `else` ` ` `dp[i] = 0;` ` ` `}` ` ` `// Return answer` ` ` `return` `dp[s.Length - 1];` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `String S = ` `"01101110"` `;` ` ` `int` `L = 2, R = 3;` ` ` `if` `(canReach(S, L, R) == 1)` ` ` `Console.WriteLine(` `"Yes"` `);` ` ` `else` ` ` `Console.WriteLine(` `"No"` `);` ` ` `}` `}` `// This code is contributed by Saurabh` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to check if it is possible` ` ` `// to reach the end of the binary string` ` ` `// using the given jumps` ` ` `const canReach = (s, L, R) => {` ` ` `// Stores the DP states` ` ` `let dp = ` `new` `Array(s.length).fill(1);` ` ` `// Stores count of indices from which` ` ` `// it is possible to reach index i` ` ` `let pre = 0;` ` ` `// Traverse the given string` ` ` `for` `(let i = 1; i < s.length; i++) {` ` ` `// Update the values of pre` ` ` `// accordingly` ` ` `if` `(i >= L) {` ` ` `pre += dp[i - L];` ` ` `}` ` ` `// If the jump size is out of` ` ` `// the range [L, R]` ` ` `if` `(i > R) {` ` ` `pre -= dp[i - R - 1];` ` ` `}` ` ` `dp[i] = (pre > 0) && (s[i] == ` `'0'` `);` ` ` `}` ` ` `// Return answer` ` ` `return` `dp[s.length - 1];` ` ` `}` ` ` `// Driver Code` ` ` `let S = ` `"01101110"` `;` ` ` `let L = 2, R = 3;` ` ` `if` `(canReach(S, L, R)) document.write(` `"Yes"` `);` ` ` `else` `document.write(` `"No"` `);` `// This code is contributed by rakeshsahni` `</script>` |

**Output:**

No

**Time Complexity:** O(N)**Auxiliary Space:** O(N)