Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]

class Solution {
    calcEquation(equations, values, queries) {
        const graph = new Map();

        for (let i = 0; i < equations.length; i++) {
            const [A, B] = equations[i];
            const value = values[i];
            if (!graph.has(A)) graph.set(A, new Map());
            if (!graph.has(B)) graph.set(B, new Map());
            graph.get(A).set(B, value);
            graph.get(B).set(A, 1.0 / value);
        }

        const bfs = (start, end) => {
            if (!graph.has(start) || !graph.has(end)) return -1.0;
            const q = [[start, 1.0]];
            const visited = new Set();
            
            while (q.length) {
                const [current, curProduct] = q.shift();
                if (current === end) return curProduct;
                visited.add(current);
                for (const [neighbor, value] of graph.get(current).entries()) {
                    if (!visited.has(neighbor)) {
                        q.push([neighbor, curProduct * value]);
                    }
                }
            }
            return -1.0;
        };

        return queries.map(([C, D]) => bfs(C, D));
    }
}

Input: n = 5
Output: [0,1,1,2,1,2]
Explanation:
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101

var countBits = function(num) {
    let ans = new Array(num + 1).fill(0);
    for (let x = 1; x <= num; x++) {
        ans[x] = ans[x & (x - 1)] + 1;
    }
    return ans;
};

Input: arr1 = [1,2,3,4,5], arr2 = [1,2,5,7,9], arr3 = [1,3,4,5,8]
Output: [1,5]
Explanation: Only 1 and 5 appeared in the three arrays.

class Solution {
    arraysIntersection(arr1, arr2, arr3) {
        const counter = new Map();
        
        for (const e of arr1) counter.set(e, (counter.get(e) || 0) + 1);
        for (const e of arr2) counter.set(e, (counter.get(e) || 0) + 1);
        for (const e of arr3) counter.set(e, (counter.get(e) || 0) + 1);

        const ans = [];
        for (const [key, value] of counter) {
            if (value === 3) ans.push(key);
        }

        return ans;
    }
}

Input: root = [4,2,6,1,3,5,7], target = 2
Output: [[2,1],[4,3,6,null,null,5,7]]

function TreeNode(val) {
    this.val = val;
    this.left = this.right = null;
}

var splitBST = function(root, target) {
    if (!root) {
        return [null, null];
    }

    if (root.val > target) {
        let left = splitBST(root.left, target);
        root.left = left[1];
        return [left[0], root];
    } else {
        let right = splitBST(root.right, target);
        root.right = right[0];
        return [root, right[1]];
    }
};

Input: timeSeries = [1,4], duration = 2
Output: 4
Explanation: Teemo's attacks on Ashe go as follows:
- At second 1, Teemo attacks, and Ashe is poisoned for seconds 1 and 2.
- At second 4, Teemo attacks, and Ashe is poisoned for seconds 4 and 5.
Ashe is poisoned for seconds 1, 2, 4, and 5, which is 4 seconds in total.

class Solution {
    findPoisonedDuration(timeSeries, duration) {
        const n = timeSeries.length;
        if (n === 0) return 0;

        let total = 0;
        for (let i = 0; i < n - 1; i++) {
            total += Math.min(timeSeries[i + 1] - timeSeries[i], duration);
        }
        return total + duration;
    }
}

Input: root = [1,2,3,4], x = 4, y = 3
Output: false

class TreeNode {
    constructor(val = 0, left = null, right = null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

var isCousins = function(root, x, y) {
    let parentX = null, parentY = null;
    let depthX = -1, depthY = -1;
    
    function dfs(node, parent, depth) {
        if (!node) return;
        if (node.val === x) {
            parentX = parent;
            depthX = depth;
        } else if (node.val === y) {
            parentY = parent;
            depthY = depth;
        } else {
            dfs(node.left, node, depth + 1);
            dfs(node.right, node, depth + 1);
        }
    }
    
    dfs(root, null, 0);
    return depthX === depthY && parentX !== parentY;
};

Input: length = 5, updates = [[1,3,2],[2,4,3],[0,2,-2]]
Output: [-2,0,3,5,3]

function getModifiedArray(length, updates) {
    let result = new Array(length).fill(0);

    for (let update of updates) {
        let [start, end, val] = update;
        result[start] += val;
        if (end + 1 < length) {
            result[end + 1] -= val;
        }
    }

    for (let i = 1; i < length; i++) {
        result[i] += result[i - 1];
    }

    return result;
}

Input: x = 4
Output: 2
Explanation: The square root of 4 is 2, so we return 2.

var mySqrt = function (x) {
    if (x < 2) return x;
    let num;
    let pivot,
        left = 2,
        right = Math.floor(x / 2);
    while (left <= right) {
        pivot = left + Math.floor((right - left) / 2);
        num = pivot * pivot;
        if (num > x) right = pivot - 1;
        else if (num < x) left = pivot + 1;
        else return pivot;
    }
    return right;
};

Input: root = [3,4,5,1,3,null,1]
Output: 9
Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.

function TreeNode(val, left, right) {
    this.val = val;
    this.left = left;
    this.right = right;
}

var rob = function(root) {
    var helper = function(node) {
        if (!node) {
            return [0, 0];
        }

        let left = helper(node.left);
        let right = helper(node.right);

        let rob = node.val + left[1] + right[1];
        let notRob = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);

        return [rob, notRob];
    };

    let answer = helper(root);
    return Math.max(answer[0], answer[1]);
};

Input: root = [[1,null],null,[4,3],[7,0]]
Output: [[1,null],null,[4,3],[7,0]]
Explanation: The original binary tree is [1,null,4,7].
The random pointer of node one is null, so it is represented as [1, null].
The random pointer of node 4 is node 7, so it is represented as [4, 3] where 3 is the index of node 7 in the array representing the tree.
The random pointer of node 7 is node 1, so it is represented as [7, 0] where 0 is the index of node 1 in the array representing the tree.

function Node(val, left, right, random) {
    this.val = val;
    this.left = left;
    this.right = right;
    this.random = random;
}

function NodeCopy(val, left, right, random) {
    this.val = val;
    this.left = left;
    this.right = right;
    this.random = random;
}

var copyRandomBinaryTree = function(root) {
    let newOldPairs = new Map();

    function deepCopy(node) {
        if (!node) return null;
        let newNode = new NodeCopy(node.val);
        newNode.left = deepCopy(node.left);
        newNode.right = deepCopy(node.right);
        newOldPairs.set(node, newNode);
        return newNode;
    }

    function mapRandomPointers(node) {
        if (!node) return;
        let newNode = newOldPairs.get(node);
        if (newNode) {
            newNode.random = newOldPairs.get(node.random);
            mapRandomPointers(node.left);
            mapRandomPointers(node.right);
        }
    }

    let newRoot = deepCopy(root);
    mapRandomPointers(root);
    return newRoot;
};

Input: trees = [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]
Output: [[1,1],[2,0],[4,2],[3,3],[2,4]]
Explanation: All the trees will be on the perimeter of the fence except the tree at [2, 2], which will be inside the fence.

var orientation = function(p, q, r) {
    return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);
};

var outerTrees = function(points) {
    points.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
    const hull = [];

    for (let point of points) {
        while (hull.length >= 2 && orientation(hull[hull.length - 2], hull[hull.length - 1], point) > 0) {
            hull.pop();
        }
        hull.push(point);
    }

    hull.pop();

    for (let i = points.length - 1; i >= 0; i--) {
        while (hull.length >= 2 && orientation(hull[hull.length - 2], hull[hull.length - 1], points[i]) > 0) {
            hull.pop();
        }
        hull.push(points[i]);
    }

    const uniqueHull = new Set(hull.map(JSON.stringify));
    return Array.from(uniqueHull).map(JSON.parse);
};

Input: nums = [1,2,1,2,6,7,5,1], k = 2
Output: [0,3,5]
Explanation: Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger.

class Solution {
    maxSumOfThreeSubarrays(nums, k) {
        const W = new Array(nums.length - k + 1).fill(0);
        let currSum = 0;
        for (let i = 0; i < nums.length; i++) {
            currSum += nums[i];
            if (i >= k) {
                currSum -= nums[i - k];
            }
            if (i >= k - 1) {
                W[i - k + 1] = currSum;
            }
        }

        const left = new Array(W.length).fill(0);
        let best = 0;
        for (let i = 0; i < W.length; i++) {
            if (W[i] > W[best]) best = i;
            left[i] = best;
        }

        const right = new Array(W.length).fill(0);
        best = W.length - 1;
        for (let i = W.length - 1; i >= 0; i--) {
            if (W[i] >= W[best]) best = i;
            right[i] = best;
        }

        const ans = [-1, -1, -1];
        for (let j = k; j < W.length - k; j++) {
            const i = left[j - k];
            const l = right[j + k];
            if (ans[0] === -1 || W[i] + W[j] + W[l] > W[ans[0]] + W[ans[1]] + W[ans[2]]) {
                ans[0] = i;
                ans[1] = j;
                ans[2] = l;
            }
        }
        return ans;
    }
}

Input: matrix =
[
  [0,1,1,1],
  [1,1,1,1],
  [0,1,1,1]
]
Output: 15

var countSquares = function(matrix) {
    let m = matrix.length, n = matrix[0].length;
    let dp = Array.from({ length: m }, () => Array(n).fill(0));
    let count = 0;

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (matrix[i][j] === 1) {
                if (i === 0 || j === 0) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1;
                }
                count += dp[i][j];
            }
        }
    }

    return count;
};