Skip to content

Commit f7c7b83

Browse files
aakhtar3aakhtar3
committed
refactor: js - aGraph
1 parent fc7683e commit f7c7b83

6 files changed

+444
-277
lines changed

‎javascript/1584-Min-Cost-to-Connect-all-Points.js

+56-110
Original file line numberDiff line numberDiff line change
@@ -1,124 +1,70 @@
1-
// Min Heap Implementation
1+
/**
2+
* Prim's algorithm
3+
* https://leetcode.com/problems/min-cost-to-connect-all-points/solution/
4+
* @param {number[][]} points
5+
* @return {number}
6+
*/
7+
const minCostConnectPoints = (points) => {
8+
const isBaseCase = ((points.length === 0) || (1000 <= points.length));
9+
if (isBaseCase) return 0;
10+
11+
const { graph, seen, minHeap } = buildGraph(points);
12+
13+
return search(points, graph, seen, minHeap);
14+
};
15+
16+
const initGraph = (points) => ({
17+
graph: new Array(points.length).fill().map(() => []),
18+
seen: new Array(points.length).fill(false),
19+
minHeap: new MinPriorityQueue()
20+
})
21+
22+
const buildGraph = (points) => {
23+
const { graph, seen, minHeap } = initGraph(points);
24+
25+
for (let src = 0; src < (points.length - 1); src++) {
26+
for (let dst = (src + 1); (dst < points.length); dst++) {
27+
const cost = getCost(points, src, dst);
228

3-
class MinHeap {
4-
constructor(nums) {
5-
this.data = [];
6-
for (let i = 0; i < nums.length; i++) {
7-
this.add(nums[i]);
29+
graph[src].push([ dst, cost ]);
30+
graph[dst].push([ src, cost ]);
831
}
932
}
1033

11-
getParentIndex = (i) => Math.floor((i - 1) / 2);
34+
const [ src, cost, priority ] = [ 0, 0, 0 ];
35+
const node = [ src, cost ];
1236

13-
getLeftChildIndex = (i) => i * 2 + 1;
37+
minHeap.enqueue(node, priority);
1438

15-
getRightChildIndex = (i) => i * 2 + 2;
39+
return { graph, seen, minHeap };
40+
}
1641

17-
swap = (i1, i2) => {
18-
const tmp = this.data[i1];
19-
this.data[i1] = this.data[i2];
20-
this.data[i2] = tmp;
21-
};
42+
const getCost = (points, src, dst) => {
43+
const [ [ x1, y1 ], [ x2, y2 ] ] = [ points[src], points[dst] ];
2244

23-
add = (e) => {
24-
this.data[this.data.length] = e;
25-
this.heapify(this.data.length - 1);
26-
return this.data[0];
27-
};
45+
return (Math.abs(x1 - x2) + Math.abs(y1 - y2));
46+
}
2847

29-
heapify = (curIndex) => {
30-
if (
31-
this.data[this.getParentIndex(curIndex)] !== undefined &&
32-
this.data[curIndex][0] < this.data[this.getParentIndex(curIndex)][0]
33-
) {
34-
this.swap(curIndex, this.getParentIndex(curIndex));
35-
this.heapify(this.getParentIndex(curIndex));
36-
}
37-
};
38-
39-
pop = () => {
40-
const firstElement = this.data[0];
41-
if (this.data.length > 1) {
42-
// replace it with the last element in heap
43-
this.data[0] = this.data[this.data.length - 1];
44-
// remove last elem
45-
this.data.pop();
46-
this.heapifyDown();
47-
}
48+
const search = (points, graph, seen, minHeap, nodeCount = 0, cost = 0) => {
49+
while (nodeCount < points.length) {
50+
let [ src, srcCost ] = minHeap.dequeue().element;
4851

49-
return firstElement;
50-
};
51-
52-
heapifyDown = () => {
53-
let cur = 0;
54-
55-
while (this.data[this.getLeftChildIndex(cur)] !== undefined) {
56-
// get the smallest child (right or left)
57-
let smallChildInd = this.getLeftChildIndex(cur);
58-
if (
59-
this.data[this.getRightChildIndex(cur)] !== undefined &&
60-
this.data[this.getRightChildIndex(cur)][0] <
61-
this.data[this.getLeftChildIndex(cur)][0]
62-
) {
63-
smallChildInd = this.getRightChildIndex(cur);
64-
}
65-
// if one child (r or l) is less than curr we swap
66-
if (this.data[smallChildInd][0] < this.data[cur][0]) {
67-
this.swap(cur, smallChildInd);
68-
}
69-
cur = smallChildInd;
70-
}
71-
};
52+
if (seen[src]) continue;
53+
seen[src] = true;
54+
55+
cost += srcCost;
56+
nodeCount += 1;
57+
58+
checkNeighbors(graph, src, seen, minHeap);
59+
}
60+
61+
return cost;
7262
}
7363

74-
const minCostConnectPoints = function (points) {
75-
const n = points.length;
76-
let finalCost = 0;
77-
78-
if (n > 1 && n <= 1000) {
79-
let x1, x2;
80-
let y1, y2;
81-
let dist;
82-
83-
const adjList = new Map();
84-
// prepare adjacent list (each node has cost to every other node)
85-
for (let i = 0; i < n - 1; i++) {
86-
[x1, y1] = points[i];
87-
88-
for (let j = i + 1; j < n; j++) {
89-
[x2, y2] = points[j];
90-
dist = Math.abs(x1 - x2) + Math.abs(y1 - y2);
91-
adjList.get(i)
92-
? adjList.get(i).push([dist, j])
93-
: adjList.set(i, [[dist, j]]);
94-
adjList.get(j)
95-
? adjList.get(j).push([dist, i])
96-
: adjList.set(j, [[dist, i]]);
97-
}
98-
}
64+
const checkNeighbors = (graph, src, seen, minHeap) => {
65+
for (const [ dst, dstCost ] of graph[src]) {
66+
if (seen[dst]) continue;
9967

100-
// prim's algorithm
101-
const visited = new Set();
102-
const minHeap = new MinHeap([[0, 0]]); // [cost,point]
103-
// we gonna visit each node
104-
while (visited.size < n) {
105-
let partialCost = 0,
106-
i = 0;
107-
108-
// get the least cost & its correspondent node
109-
[partialCost, i] = minHeap.pop();
110-
111-
// if the node hasn't been visited
112-
if (!visited.has(i)) {
113-
finalCost += partialCost;
114-
visited.add(i);
115-
for (const neighbourWithCost of adjList.get(i)) {
116-
if (!visited.has(neighbourWithCost[1])) {
117-
minHeap.add(neighbourWithCost);
118-
}
119-
}
120-
}
121-
}
68+
minHeap.enqueue([ dst, dstCost ], dstCost);
12269
}
123-
return finalCost;
124-
};
70+
}

‎javascript/269-Alien-Dictionary.js

+160-36
Original file line numberDiff line numberDiff line change
@@ -1,55 +1,179 @@
1-
let alienOrder = function (words) {
2-
let graph = {};
1+
/**
2+
* BFS
3+
* https://leetcode.com/problems/alien-dictionary/
4+
* @param {string[]} words
5+
* @return {string}
6+
*/
7+
var alienOrder = function(words) {
8+
const { graph, frequencyMap, queue, buffer } = buildGraph(words);
39

4-
for (let i = 0; i < words.length; i++) {
5-
for (let j = 0; j < words[i].length; j++) {
6-
graph[words[i][j]] = new Set();
10+
if (!canBuildGraph(words, graph, frequencyMap)) return '';
11+
12+
queueSources(queue, frequencyMap);
13+
bfs(queue, frequencyMap, graph, buffer);
14+
15+
return (frequencyMap.size <= buffer.length)
16+
? buffer.join('')
17+
: '';
18+
}
19+
20+
var initGraph = () => ({
21+
graph: new Map(),
22+
frequencyMap: new Map(),
23+
queue: new Queue(),
24+
buffer: [],
25+
})
26+
27+
var buildGraph = (words) => {
28+
const { graph, frequencyMap, queue, buffer } = initGraph();
29+
30+
for (const word of words) {
31+
for (const char of word) {
32+
frequencyMap.set(char, 0);
33+
graph.set(char, []);
734
}
835
}
936

10-
for (let i = 0; i < words.length - 1; i++) {
11-
let word1 = words[i];
12-
let word2 = words[i + 1];
37+
return { graph, frequencyMap, queue, buffer };
38+
};
39+
40+
var canBuildGraph = (words, graph, frequencyMap) => {
41+
for (let index = 0; (index < words.length - 1); index++) {
42+
const [ word1, word2 ] = [ words[index], words[(index + 1)] ];
43+
const minLength = Math.min(word1.length, word2.length)
1344

14-
if (word1.length > word2.length && (word1 + '').startsWith(word2)) {
15-
return '';
16-
}
45+
const isWord1Longer = (word2.length < word1.length);
46+
const isPrefix = isWord1Longer && word1.startsWith(word2);
47+
48+
if (isPrefix) return false;
1749

18-
for (let j = 0; j < Math.min(word1.length, word2.length); j++) {
19-
let c1 = word1[j];
20-
let c2 = word2[j];
50+
for (let j = 0; (j < minLength); j++) {
51+
const [ char1, char2 ] = [ word1[j], word2[j] ];
2152

22-
if (c1 !== c2) {
23-
graph[c1].add(c2);
24-
break;
25-
}
53+
const isEqual = (char1 === char2);
54+
if (isEqual) continue;
55+
56+
graph.get(char1).push(char2);
57+
frequencyMap.set(char2, frequencyMap.get(char2) + 1);
58+
59+
break;
2660
}
2761
}
2862

29-
let visited = {}; // 'false' = visited, 'true' = current path
30-
let res = [];
63+
return true;
64+
};
3165

32-
function dfs(c) {
33-
if (visited[c]) {
34-
return Boolean(visited[c]);
66+
const bfs = (queue, frequencyMap, graph, buffer) => {
67+
while (!queue.isEmpty()) {
68+
for (let level = (queue.size() - 1); (0 <= level); level--) {
69+
checkNeighbors(queue, frequencyMap, graph, buffer)
3570
}
71+
}
72+
};
3673

37-
visited[c] = 'true';
38-
for (let nei of graph[c]) {
39-
if (dfs(nei)) {
40-
return true;
41-
}
42-
}
74+
var checkNeighbors = (queue, frequencyMap, graph, buffer) => {
75+
const char = queue.dequeue();
76+
77+
buffer.push(char);
78+
79+
for (const next of graph.get(char)) {
80+
const value = (frequencyMap.get(next) - 1);
81+
82+
frequencyMap.set(next, value);
4383

44-
visited[c] = 'false';
45-
res.push(c);
84+
const isEmpty = (frequencyMap.get(next) === 0);
85+
if (!isEmpty) continue;
86+
87+
queue.enqueue(next);
88+
}
89+
}
90+
91+
const queueSources = (queue, frequencyMap) => {
92+
for (const [ key, value ] of frequencyMap) {
93+
const isEmpty = (frequencyMap.get(key) === 0);
94+
if (!isEmpty) continue;
95+
96+
queue.enqueue(key);
4697
}
98+
}
99+
100+
/**
101+
* DFS
102+
* https://leetcode.com/problems/alien-dictionary/
103+
* @param {string[]} words
104+
* @return {string}
105+
*/
106+
var alienOrder = function(words) {
107+
const { graph, seen, buffer } = buildGraph(words);
108+
109+
if (!canBuildGraph(words, graph)) return '';
47110

48-
Object.keys(graph).forEach((c) => {
49-
if (dfs(c)) {
50-
return '';
111+
for (const [ char ] of graph) {
112+
if (!dfs(char, graph, seen, buffer)) return '';
113+
}
114+
115+
return buffer.reverse().join('')
116+
}
117+
118+
var initGraph = () => ({
119+
graph: new Map(),
120+
seen: new Map(),
121+
buffer: [],
122+
})
123+
124+
var buildGraph = (words) => {
125+
const { graph, seen, buffer } = initGraph();
126+
127+
for (const word of words) {
128+
for (const char of word) {
129+
graph.set(char, []);
51130
}
52-
});
131+
}
53132

54-
return res.reverse().join('');
133+
return { graph, seen, buffer };
55134
};
135+
136+
var canBuildGraph = (words, graph) => {
137+
for (let index = 0; (index < words.length - 1); index++) {
138+
const [ word1, word2 ] = [ words[index], words[(index + 1)] ];
139+
const minLength = Math.min(word1.length, word2.length)
140+
141+
const isWord1Longer = (word2.length < word1.length);
142+
const isPrefix = isWord1Longer && word1.startsWith(word2);
143+
144+
if (isPrefix) return false;
145+
146+
for (let j = 0; (j < minLength); j++) {
147+
const [ char1, char2 ] = [ word1[j], word2[j] ];
148+
149+
const isEqual = (char1 === char2);
150+
if (isEqual) continue;
151+
152+
graph.get(char1).push(char2);
153+
154+
break;
155+
}
156+
}
157+
158+
return true;
159+
};
160+
161+
const dfs = (char, graph, seen, buffer) => {
162+
if (seen.has(char)) return seen.get(char);
163+
164+
if (!backTrack(char, graph, seen, buffer)) return false;
165+
166+
buffer.push(char);
167+
168+
return true;
169+
}
170+
171+
const backTrack = (char, graph, seen, buffer) => {
172+
seen.set(char, false);
173+
for (const neighbor of graph.get(char)) {
174+
if (!dfs(neighbor, graph, seen, buffer)) return false;
175+
}
176+
seen.set(char, true);
177+
178+
return true;
179+
}

0 commit comments

Comments
 (0)