Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Oct 24, 2024
Merged

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

Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
d3faab0
Create 1443-minimum-time-to-collect-all-apples-in-a-tree.js
aadil42 Aug 5, 2024
52c4ab6
Update with graph approach. Add spaces after control flow statements.
aadil42 Oct 18, 2024
8637c07
Add Space.
aadil42 Oct 23, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
47 changes: 47 additions & 0 deletions javascript/1443-minimum-time-to-collect-all-apples-in-a-tree.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,47 @@
/**
* 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 tree = {};

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

const parent = edges[i][0];
const child = edges[i][1];

if(!tree[parent]) {
tree[parent] = [];
}

if(!tree[child]) {
tree[child] = [];
};

tree[child].push(parent);
tree[parent].push(child);
}

const dfs = (curr, pre) => {
Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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;
}

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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;
}

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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


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

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

const result = dfs(0, -1) - 2;
return (result > 0 && result) || 0;
};