Create 1443-minimum-time-to-collect-all-apples-in-a-tree.js

[aadil42]

Solved minimum-time-to-collect-all-apples-in-a-tree in JS.

File(s) Added: 1443-minimum-time-to-collect-all-apples-in-a-tree.js
Language(s) Used: JavaScript
Submission URL: https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/submissions/1345682712/

[aakhtar3]

Avoid nested function.
This is also a graph DS problem

/**
 * DFS
 * Hash Map - Adjacency Matrix
 * Time O(N) | Space O(N)
 * https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree
 * @param {number} n
 * @param {number[][]} edges
 * @param {boolean[]} hasApple
 * @return {number}
 */
var minTime = (n, edges, hasApple) => {
    const graph = buildGraph(edges);

    return dfs(graph, hasApple);
}

const buildGraph = (edges, graph = new Map()) => {
    for (const [ src, dst ] of edges) {
        const srcNeighbors = ((graph.get(src)) || []);

        srcNeighbors.push(dst);
        graph.set(src, srcNeighbors);

        const dstNeighbors = ((graph.get(dst)) || []);

        dstNeighbors.push(src);
        graph.set(dst, dstNeighbors);
    }

    return graph;
}

const dfs = (graph, hasApple, node = 0, parent = (-1), totalTime = 0, childTime = 0) => {
    for (const child of graph.get(node)) {
        const isEqual = (child === parent);
        if (isEqual) continue;

        childTime = dfs(graph, hasApple, child, node);
    
        const canUpdate = ((0 < childTime) || (hasApple[child]));
        if (!canUpdate) continue;
        
        totalTime += (childTime + 2);
    }

    return totalTime;
}

[aadil42]

Yep, got confused by the image in the problem. Since a Graph is a superset of a tree we'll consider it as a graph.
Modified the code, please take a look.
Submission link for the proposed code: https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/submissions/1388715220/

/**
 * Graph | DFS 
 * Time O(n) | Space O(n)
 * https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/
 * @param {number} n
 * @param {number[][]} edges
 * @param {boolean[]} hasApple
 * @return {number}
 */
var minTime = function(n, edges, hasApple) {
    if(n === 1) return 0;
    const result = dfs(0, -1, makeGraph(edges), hasApple) - 2;
    return (result > 0 && result) || 0;
};

const dfs = (curr, pre, graph, hasApple) => {
    let pathLen = 0;
    for(const nextNode of graph[curr]) {
        if(nextNode === pre) continue;
        pathLen += dfs(nextNode, curr, graph, hasApple);
    }   

    if(pathLen > 0 || hasApple[curr]) return pathLen+2;
    return 0;
}

const makeGraph = (edges) => {
    const graph = {};

    for(let i = 0; i < edges.length; i++) {

        const from = edges[i][0];
        const to = edges[i][1];

        if(!graph[from]) {
            graph[from] = [];
        }

        if(!graph[to]) {
            graph[to] = [];
        };

        graph[to].push(from);
        graph[from].push(to);
    }

    return graph;
}

[aadil42]

@aakhtar3 (tagging to draw attention to the proposed code)

[Ykhan799]

@aadil42 For line 23, add spacing for pathLen + 2. Other than that, the rest of the solution looks good 👍

[aadil42]

@Ykhan799, done. Sorry for the late commits. Thank you for considering my solutions.