Skip to content

Commit 66fbb23

Browse files
aakhtar3aakhtar3
authored
Merge pull request #1177 from aakhtar3/1dp
refactor: js - 1dp
2 parents 7f95db3 + 8377ec3 commit 66fbb23

12 files changed

+1276
-174
lines changed

Diff for: ‎javascript/139-Word-Break.js

+176-17
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,179 @@
1-
let wordBreak = function (s, wordDict) {
2-
let dp = new Array(s.length + 1).fill(false);
3-
dp[s.length] = true;
4-
5-
for (let i = s.length - 1; i >= 0; i--) {
6-
for (let w of wordDict) {
7-
if (
8-
i + w.length <= s.length &&
9-
s.substring(i, i + w.length) === w
10-
) {
11-
dp[i] = dp[i + w.length];
12-
}
13-
if (dp[i]) {
14-
break;
15-
}
1+
/**
2+
* Brute Force - DFS
3+
* Hash Set - Distinct Keys
4+
* Time O(2^N) | Space O(N)
5+
* https://leetcode.com/problems/word-break/
6+
* @param {string} s
7+
* @param {string[]} wordDict
8+
* @return {boolean}
9+
*/
10+
var wordBreak = (s, wordDict) => {
11+
const wordSet = new Set(wordDict);/* Time O(N) | Space O(N) */
12+
13+
return canBreak(s, wordSet); /* Time O(2^N) | Space O(N) */
14+
};
15+
16+
var canBreak = (s, wordSet, start = 0) => {
17+
const isBaseCase = (start === s.length);
18+
if (isBaseCase) return true;
19+
20+
return dfs(s, wordSet, start);/* Time O(2^N) | Space O(N) */
21+
}
22+
23+
var dfs = (s, wordSet, start) => {
24+
for (let end = (start + 1); end <= s.length; end++) {/* Time O(N) */
25+
const word = s.slice(start, end); /* Time O(N) | Space O(N) */
26+
27+
const _canBreak = wordSet.has(word)
28+
&& canBreak(s, wordSet, end); /* Time O(2^N) | Space O(N) */
29+
if (_canBreak) return true;
30+
}
31+
32+
return false;
33+
}
34+
35+
/**
36+
* DP - Top Down
37+
* Array - Memoization
38+
* Hash Set - Distinct Keys
39+
* Time O(N^3) | Space O(N)
40+
* https://leetcode.com/problems/word-break/
41+
* @param {string} s
42+
* @param {string[]} wordDict
43+
* @return {boolean}
44+
*/
45+
var wordBreak = (s, wordDict) => {
46+
const wordSet = new Set(wordDict); /* Time O(N) | Space O(N) */
47+
const memo = new Array(s.length).fill(null); /* | Space O(N) */
48+
const start = 0;
49+
50+
return canBreak(s, wordSet, start, memo); /* Time O(N * N * N) | Space O(N) */
51+
}
52+
53+
var canBreak = (s, wordSet, start, memo) => {
54+
const isBaseCase1 = (s.length === start);
55+
if (isBaseCase1) return true;
56+
57+
const hasSeen = (memo[start] !== null);
58+
if (hasSeen) return memo[start];
59+
60+
return dfs(s, wordSet, start, memo);/* Time O(N * N * N) | Space O(N) */
61+
}
62+
63+
var dfs = (s, wordSet, start, memo) => {
64+
for (let end = (start + 1); (end <= s.length); end++) {/* Time O(N) */
65+
const word = s.slice(start, end); /* Time O(N) | Space O(N) */
66+
67+
const _canBreak = wordSet.has(word)
68+
&& canBreak(s, wordSet, end, memo); /* Time O(N * N) */
69+
if (_canBreak) {
70+
memo[start] = true;
71+
return true;
1672
}
1773
}
1874

19-
return dp[0];
20-
};
75+
memo[start] = false;
76+
return false;
77+
}
78+
79+
/**
80+
* DP - Bottom Up
81+
* Array - Tabulation
82+
* Hash Set - Distinct Keys
83+
* Time O(N^3) | Space O(N)
84+
* https://leetcode.com/problems/word-break/
85+
* @param {string} s
86+
* @param {string[]} wordDict
87+
* @return {boolean}
88+
*/
89+
var wordBreak = (s, wordDict) => {
90+
const wordSet = new Set(wordDict);/* Time O(N) | Space O(N) */
91+
const tabu = initTabu(s); /* | Space O(N) */
92+
93+
canBreak(s, wordSet, tabu); /* Time O(N * N * N) | Space O(N) */
94+
95+
return tabu[s.length];
96+
}
97+
98+
const initTabu = (s) => {
99+
const tabu = new Array((s.length + 1)).fill(false);/* Space O(N) */
100+
101+
tabu[0] = true;
102+
103+
return tabu;
104+
}
105+
106+
var canBreak = (s, wordSet, tabu) => {
107+
for (let end = 1; (end <= s.length); end++) {/* Time O(N) */
108+
checkWord(s, wordSet, end, tabu); /* Time O(N * N) | Space O(N) */
109+
}
110+
}
111+
112+
var checkWord = (s, wordSet, end, tabu) => {
113+
for (let start = 0; (start < end); start++) {/* Time O(N) */
114+
const word = s.slice(start, end); /* Time O(N) | Space O(N) */
115+
116+
const canBreak = tabu[start] && wordSet.has(word);
117+
if (!canBreak) continue;
118+
119+
tabu[end] = true;
120+
121+
return;
122+
}
123+
}
124+
125+
/**
126+
* Tree Traversal - BFS
127+
* Queue - Level Order Space O(WIDTH)
128+
* Hash Set - Distinct Keys
129+
* Array - Seen
130+
* Time O(N^3) | Space O(N)
131+
* https://leetcode.com/problems/word-break/
132+
* @param {string} s
133+
* @param {string[]} wordDict
134+
* @return {boolean}
135+
*/
136+
var wordBreak = function(s, wordDict) {
137+
const wordSet = new Set(wordDict); /* Time O(N) | Space O(N) */
138+
const queue = new Queue([ 0 ]); /* | Space O(N) */
139+
const seen = new Array(s.length).fill(false);/* | Space O(N) */
140+
141+
return bfs(queue, s, wordSet, seen); /* Time O(N * N * N) | Space O(N + WIDTH) */
142+
}
143+
144+
const bfs = (queue, s, wordSet, seen) => {
145+
while (!queue.isEmpty()) {
146+
for (let level = (queue.size() - 1); (0 <= level); level--) {/* Time O(N) */
147+
if (canWordBreak(queue, s, wordSet, seen)) return true; /* Time O(N * N) | Space O(N + WIDTH) */
148+
}
149+
}
150+
151+
return false;
152+
}
153+
154+
var canWordBreak = (queue, s, wordSet, seen) => {
155+
const start = queue.dequeue();
156+
157+
const hasSeen = seen[start];
158+
if (hasSeen) return false;
159+
160+
if (canBreak(queue, s, start, wordSet)) return true;/* Time O(N * N) | Space O(N + WIDTH) */
161+
162+
seen[start] = true; /* | Space O(N) */
163+
return false;
164+
}
165+
166+
var canBreak = (queue, s, start, wordSet) => {
167+
for (let end = start + 1; end <= s.length; end++) {/* Time O(N) */
168+
const word = s.slice(start, end); /* Time O(N) | Space O(N) */
169+
170+
if (!wordSet.has(word)) continue;
171+
172+
queue.enqueue(end); /* | Space O(WIDTH) */
173+
174+
const _canBreak = end === s.length;
175+
if (_canBreak) return true;
176+
}
177+
178+
return false
179+
}

Diff for: ‎javascript/152-Maximum-Product-Subarray.js

+53-13
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,59 @@
11
/**
2+
* Brute Force - Linear Search
3+
* Time O(N^2) | Space O(1)
4+
* https://leetcode.com/problems/maximum-product-subarray/
25
* @param {number[]} nums
36
* @return {number}
47
*/
5-
var maxProduct = function (nums) {
6-
let result = nums[0];
7-
let prevMax = nums[0];
8-
let prevMin = nums[0];
9-
for (let i = 1; i < nums.length; i++) {
10-
currMax = Math.max(nums[i], prevMax * nums[i], prevMin * nums[i]);
11-
currMin = Math.min(nums[i], prevMax * nums[i], prevMin * nums[i]);
12-
13-
prevMax = currMax;
14-
prevMin = currMin;
15-
16-
result = Math.max(currMax, result);
8+
var maxProduct = (nums) => {
9+
const isEmpty = nums.length === 0;
10+
if (isEmpty) return 0;
11+
12+
return linearSearch(nums);/* Time O(N * N) */
13+
}
14+
15+
const linearSearch = (nums, max = nums[0]) => {
16+
for (let index = 0; index < nums.length; index++) {/* Time O(N) */
17+
max = getMax(nums, index, max); /* Time O(N) */
18+
}
19+
20+
return max;
21+
}
22+
23+
const getMax = (nums, index, max, product = 1) => {
24+
for (let num = index; num < nums.length; num++) {/* Time O(N) */
25+
product *= nums[num];
26+
max = Math.max(max, product);
1727
}
18-
return result;
28+
29+
return max;
30+
}
31+
32+
/**
33+
* Greedy - product
34+
* Time O(N) | Space O(1)
35+
* https://leetcode.com/problems/maximum-product-subarray/
36+
* @param {number[]} nums
37+
* @return {number}
38+
*/
39+
var maxProduct = (nums) => {
40+
const isEmpty = nums.length === 0;
41+
if (isEmpty) return 0;
42+
43+
return greedySearch(nums);/* Time O(N) */
1944
};
45+
46+
const greedySearch = (nums) => {
47+
let min = max = product = nums[0];
48+
49+
for (let num = 1; num < nums.length; num++) {/* Time O(N) */
50+
const [ minProduct, maxProduct ] = [ (min * nums[num]), (max * nums[num]) ];
51+
52+
min = Math.min(maxProduct, minProduct, nums[num]);
53+
max = Math.max(maxProduct, minProduct, nums[num]);
54+
55+
product = Math.max(product, max);
56+
}
57+
58+
return product;
59+
}

Diff for: ‎javascript/198-House-Robber.js

+100-9
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,103 @@
1-
function rob(nums) {
2-
let rob1 = 0;
3-
let rob2 = 0;
4-
5-
for (const n of nums) {
6-
let temp = Math.max(n + rob1, rob2);
7-
rob1 = rob2;
8-
rob2 = temp;
1+
/**
2+
* Brute Force - DFS
3+
* Time O(2^N) | Space O(N)
4+
* https://leetcode.com/problems/house-robber/
5+
* @param {number[]} nums
6+
* @return {number}
7+
*/
8+
var rob = (nums, i = 0) => {
9+
const isBaseCase = nums <= i;
10+
if (isBaseCase) return 0;
11+
12+
const [ next, nextNext ] = [ (i + 1), (i + 2) ];
13+
const right = nums[i];
14+
const mid = rob(nums, next); /* Time O(2^N) | Space O(N) */
15+
const left = rob(nums, nextNext);/* Time O(2^N) | Space O(N) */
16+
const house = left + right;
17+
18+
return Math.max(house, mid);
19+
};
20+
21+
/**
22+
* DP - Top Down
23+
* Array - Memoization
24+
* Time O(N) | Space O(N)
25+
* https://leetcode.com/problems/house-robber/
26+
* @param {number[]} nums
27+
* @return {number}
28+
*/
29+
var rob = (nums, i = 0, memo = initMemo(nums)) => {
30+
const isBaseCase = nums.length <= i;
31+
if (isBaseCase) return 0;
32+
33+
const hasSeen = 0 <= memo[i];
34+
if (hasSeen) return memo[i];
35+
36+
const [ next, nextNext ] = [ (i + 1), (i + 2) ];
37+
const right = nums[i];
38+
const mid = rob(nums, next, memo); /* Time O(N) | Space O(N) */
39+
const left = rob(nums, nextNext, memo);/* Time O(N) | Space O(N) */
40+
const house = left + right;
41+
42+
memo[i] = Math.max(mid, house); /* | Space O(N) */
43+
44+
return memo[i];
45+
};
46+
47+
const initMemo = (nums) => Array(nums.length + 1).fill(-1);
48+
49+
/**
50+
* DP - Bottom Up
51+
* Array - Tabulation
52+
* Time O(N) | Space O(N)
53+
* https://leetcode.com/problems/house-robber/
54+
* @param {number[]} nums
55+
* @return {number}
56+
*/
57+
var rob = (nums) => {
58+
if (!nums.length) return 0;
59+
60+
const tabu = initTabu(nums);
61+
62+
for (let i = 1; i < nums.length; i++) {/* Time O(N) */
63+
const right = nums[i];
64+
const mid = tabu[i];
65+
const left = tabu[i - 1];
66+
const house = left + right;
67+
68+
tabu[i + 1] = Math.max(mid, house); /* Space O(N) */
969
}
1070

11-
return rob2;
71+
return tabu[nums.length]
72+
};
73+
74+
const initTabu = (nums) => {
75+
const tabu = Array(nums.length + 1).fill(0);
76+
77+
tabu[1] = nums[0];
78+
79+
return tabu;
1280
}
81+
82+
/**
83+
* DP - Bottom Up
84+
* Time O(N) | Space O(1)
85+
* https://leetcode.com/problems/house-robber/
86+
* @param {number[]} nums
87+
* @return {number}
88+
*/
89+
var rob = (nums) => {
90+
if (!nums.length) return 0;
91+
92+
let [ left, mid ] = [ 0, 0 ];
93+
94+
for (const right of nums) {/* Time O(N) */
95+
const temp = mid;
96+
const house = left + right;
97+
98+
mid = Math.max(mid, house);
99+
left = temp;
100+
}
101+
102+
return mid;
103+
};

0 commit comments

Comments
 (0)