feat: add js solution to lc problem: No.1530 (#3289)

Author: rain84

solution/1500-1599/1530.Number of Good Leaf Nodes Pairs/README.md

@@ -270,6 +270,93 @@ func dfs(root *TreeNode, cnt []int, i int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+function countPairs(root: TreeNode | null, distance: number): number {
+    const pairs: number[][] = [];
+
+    const dfs = (node: TreeNode | null): number[][] => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res: number[][] = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+}
+```
+
+#### JavaScript
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} distance
+ * @return {number}
+ */
+var countPairs = function (root, distance) {
+    const pairs = [];
+
+    const dfs = node => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+};
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1500-1599/1530.Number of Good Leaf Nodes Pairs/README_EN.md

@@ -245,6 +245,93 @@ func dfs(root *TreeNode, cnt []int, i int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+function countPairs(root: TreeNode | null, distance: number): number {
+    const pairs: number[][] = [];
+
+    const dfs = (node: TreeNode | null): number[][] => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res: number[][] = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+}
+```
+
+#### JavaScript
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} distance
+ * @return {number}
+ */
+var countPairs = function (root, distance) {
+    const pairs = [];
+
+    const dfs = node => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+};
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1500-1599/1530.Number of Good Leaf Nodes Pairs/Solution.js

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} distance
+ * @return {number}
+ */
+var countPairs = function (root, distance) {
+    const pairs = [];
+
+    const dfs = node => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+};

solution/1500-1599/1530.Number of Good Leaf Nodes Pairs/Solution.ts

@@ -0,0 +1,32 @@
+function countPairs(root: TreeNode | null, distance: number): number {
+    const pairs: number[][] = [];
+
+    const dfs = (node: TreeNode | null): number[][] => {
+        if (!node) return [];
+        if (!node.left && !node.right) return [[node.val, 1]];
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        for (const [x, dx] of left) {
+            for (const [y, dy] of right) {
+                if (dx + dy <= distance) {
+                    pairs.push([x, y]);
+                }
+            }
+        }
+
+        const res: number[][] = [];
+        for (const arr of [left, right]) {
+            for (const x of arr) {
+                if (++x[1] <= distance) res.push(x);
+            }
+        }
+
+        return res;
+    };
+
+    dfs(root);
+
+    return pairs.length;
+}