Skip to content

Commit 2327992

Browse files
Srihari2222Srihari2222
authored
Sri Hari: Batch-4/Neetcode-All/Added-articles (neetcode-gh#3773)
* Batch-4/Neetcode-All/Added-articles * Batch-4/Neetcode-All/Added-articles * Batch-4/Neetcode-All/Added-articles * Batch-4/Neetcode-All/Added-articles
1 parent ae946f1 commit 2327992

18 files changed

+8905
-0
lines changed

‎articles/best-team-with-no-conflicts.md

Lines changed: 649 additions & 0 deletions
Large diffs are not rendered by default.

‎articles/count-ways-to-build-good-strings.md

Lines changed: 283 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,283 @@
1+
## 1. Recursion
2+
3+
::tabs-start
4+
5+
```python
6+
class Solution:
7+
def countGoodStrings(self, low: int, high: int, zero: int, one: int) -> int:
8+
mod = 10**9 + 7
9+
10+
def dfs(length):
11+
if length > high:
12+
return 0
13+
res = 1 if length >= low else 0
14+
res += dfs(length + zero) + dfs(length + one)
15+
return res % mod
16+
17+
return dfs(0)
18+
```
19+
20+
```java
21+
public class Solution {
22+
final int mod = 1_000_000_007;
23+
24+
public int countGoodStrings(int low, int high, int zero, int one) {
25+
return dfs(low, high, zero, one, 0);
26+
}
27+
28+
private int dfs(int low, int high, int zero, int one, int length) {
29+
if (length > high) return 0;
30+
int res = (length >= low) ? 1 : 0;
31+
res = (res + dfs(low, high, zero, one, length + zero)) % mod;
32+
res = (res + dfs(low, high, zero, one, length + one)) % mod;
33+
return res;
34+
}
35+
}
36+
```
37+
38+
```cpp
39+
class Solution {
40+
public:
41+
int countGoodStrings(int low, int high, int zero, int one) {
42+
const int mod = 1e9 + 7;
43+
44+
function<int(int)> dfs = [&](int length) {
45+
if (length > high) return 0;
46+
int res = (length >= low) ? 1 : 0;
47+
res = (res + dfs(length + zero)) % mod;
48+
res = (res + dfs(length + one)) % mod;
49+
return res;
50+
};
51+
52+
return dfs(0);
53+
}
54+
};
55+
```
56+
57+
```javascript
58+
class Solution {
59+
/**
60+
* @param {number} low
61+
* @param {number} high
62+
* @param {number} zero
63+
* @param {number} one
64+
* @return {number}
65+
*/
66+
countGoodStrings(low, high, zero, one) {
67+
const mod = 1e9 + 7;
68+
69+
const dfs = length => {
70+
if (length > high) return 0;
71+
let res = length >= low ? 1 : 0;
72+
res = (res + dfs(length + zero)) % mod;
73+
res = (res + dfs(length + one)) % mod;
74+
return res;
75+
};
76+
77+
return dfs(0);
78+
}
79+
}
80+
```
81+
82+
::tabs-end
83+
84+
### Time & Space Complexity
85+
86+
* Time complexity: $O(2 ^ n)$
87+
* Space complexity: $O(n)$
88+
89+
> Where $n$ is equal to the given $high$ value.
90+
91+
---
92+
93+
## 2. Dynamic Programming (Top-Down)
94+
95+
::tabs-start
96+
97+
```python
98+
class Solution:
99+
def countGoodStrings(self, low: int, high: int, zero: int, one: int) -> int:
100+
mod = 10**9 + 7
101+
dp = {}
102+
103+
def dfs(length):
104+
if length > high:
105+
return 0
106+
if length in dp:
107+
return dp[length]
108+
109+
dp[length] = 1 if length >= low else 0
110+
dp[length] += dfs(length + zero) + dfs(length + one)
111+
return dp[length] % mod
112+
113+
return dfs(0)
114+
```
115+
116+
```java
117+
public class Solution {
118+
final int mod = 1_000_000_007;
119+
private int[] dp;
120+
121+
public int countGoodStrings(int low, int high, int zero, int one) {
122+
dp = new int[high + 1];
123+
Arrays.fill(dp, -1);
124+
return dfs(low, high, zero, one, 0);
125+
}
126+
127+
private int dfs(int low, int high, int zero, int one, int length) {
128+
if (length > high) return 0;
129+
if (dp[length] != -1) return dp[length];
130+
131+
dp[length] = (length >= low) ? 1 : 0;
132+
dp[length] = (dp[length] + dfs(low, high, zero, one, length + zero)) % mod;
133+
dp[length] = (dp[length] + dfs(low, high, zero, one, length + one)) % mod;
134+
return dp[length];
135+
}
136+
}
137+
```
138+
139+
```cpp
140+
class Solution {
141+
const int mod = 1e9 + 7;
142+
vector<int> dp;
143+
144+
public:
145+
int countGoodStrings(int low, int high, int zero, int one) {
146+
dp.assign(high + 1, -1);
147+
return dfs(low, high, zero, one, 0);
148+
}
149+
150+
private:
151+
int dfs(int low, int high, int zero, int one, int length) {
152+
if (length > high) return 0;
153+
if (dp[length] != -1) return dp[length];
154+
dp[length] = (length >= low) ? 1 : 0;
155+
dp[length] = (dp[length] + dfs(low, high, zero, one, length + zero)) % mod;
156+
dp[length] = (dp[length] + dfs(low, high, zero, one, length + one)) % mod;
157+
return dp[length];
158+
}
159+
};
160+
```
161+
162+
```javascript
163+
class Solution {
164+
/**
165+
* @param {number} low
166+
* @param {number} high
167+
* @param {number} zero
168+
* @param {number} one
169+
* @return {number}
170+
*/
171+
countGoodStrings(low, high, zero, one) {
172+
const mod = 1e9 + 7;
173+
const dp = new Array(high + 1).fill(-1);
174+
175+
const dfs = length => {
176+
if (length > high) return 0;
177+
if (dp[length] !== -1) return dp[length];
178+
dp[length] = length >= low ? 1 : 0;
179+
dp[length] = (dp[length] + dfs(length + zero)) % mod;
180+
dp[length] = (dp[length] + dfs(length + one)) % mod;
181+
return dp[length];
182+
};
183+
184+
return dfs(0);
185+
}
186+
}
187+
```
188+
189+
::tabs-end
190+
191+
### Time & Space Complexity
192+
193+
* Time complexity: $O(n)$
194+
* Space complexity: $O(n)$
195+
196+
> Where $n$ is equal to the given $high$ value.
197+
198+
---
199+
200+
## 3. Dynamic Programming (Bottom-Up)
201+
202+
::tabs-start
203+
204+
```python
205+
class Solution:
206+
def countGoodStrings(self, low: int, high: int, zero: int, one: int) -> int:
207+
dp = { 0 : 1 }
208+
mod = 10**9 + 7
209+
210+
for i in range(1, high + 1):
211+
dp[i] = (dp.get(i - one, 0) + dp.get(i - zero, 0)) % mod
212+
213+
return sum(dp[i] for i in range(low, high + 1)) % mod
214+
```
215+
216+
```java
217+
public class Solution {
218+
public int countGoodStrings(int low, int high, int zero, int one) {
219+
int[] dp = new int[high + 1];
220+
int mod = 1_000_000_007, res = 0;
221+
dp[0] = 1;
222+
223+
for (int i = 1; i <= high; i++) {
224+
if (i >= zero) dp[i] = (dp[i] + dp[i - zero]) % mod;
225+
if (i >= one) dp[i] = (dp[i] + dp[i - one]) % mod;
226+
if (i >= low) res = (res + dp[i]) % mod;
227+
}
228+
return res;
229+
}
230+
}
231+
```
232+
233+
```cpp
234+
class Solution {
235+
public:
236+
int countGoodStrings(int low, int high, int zero, int one) {
237+
vector<int> dp(high + 1);
238+
int mod = 1e9 + 7, res = 0;
239+
dp[0] = 1;
240+
241+
for (int i = 1; i <= high; i++) {
242+
if (i >= zero) dp[i] = (dp[i] + dp[i - zero]) % mod;
243+
if (i >= one) dp[i] = (dp[i] + dp[i - one]) % mod;
244+
if (i >= low) res = (res + dp[i]) % mod;
245+
}
246+
return res;
247+
}
248+
};
249+
```
250+
251+
```javascript
252+
class Solution {
253+
/**
254+
* @param {number} low
255+
* @param {number} high
256+
* @param {number} zero
257+
* @param {number} one
258+
* @return {number}
259+
*/
260+
countGoodStrings(low, high, zero, one) {
261+
const mod = 1e9 + 7;
262+
const dp = new Int32Array(high + 1);
263+
let res = 0;
264+
dp[0] = 1;
265+
266+
for (let i = 1; i <= high; i++) {
267+
if (i >= zero) dp[i] = (dp[i] + dp[i - zero]) % mod;
268+
if (i >= one) dp[i] = (dp[i] + dp[i - one]) % mod;
269+
if (i >= low) res = (res + dp[i]) % mod;
270+
}
271+
return res;
272+
}
273+
}
274+
```
275+
276+
::tabs-end
277+
278+
### Time & Space Complexity
279+
280+
* Time complexity: $O(n)$
281+
* Space complexity: $O(n)$
282+
283+
> Where $n$ is equal to the given $high$ value.

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy