Maximal Point Path - Coding

Given a tree with N nodes numbered from 1 to N. Each Node has a value denoting the number of points you get when you visit that Node. Each edge has a length and as soon as you travel through this edge number of points is reduced by the length of the edge, the task is to choose two nodes u and v such that the number of points is maximized at the end of the path from node u to node v.

Note: The number of points should not get negative in between the path from node u to node v.

Examples:

Input:

Output: Maximal Point Path in this case will be 2->1->3 and maximum points at the end of path will be (3-2+1-2+3) = 3

Input:

Output: Maximal Point Path in this case will be 2 -> 4 and maximum points at the end of path will be (3-1+5) = 7

Approach: This problem can be solved optimally using DP with trees concept.

Steps to solve the problem:

Root the tree at any node say (1).
For each of the nodes v in the tree, find the maximum points of the path passing through the node v. The answer will be the maximum of this value among all nodes in the tree.
To calculate this value for each node, maintain a dp array, where dp[v] is the maximal points of the path starting at node v for the subtree rooted at node v. dp[v] for a node v can be calculated from points[v] + max(dp[u] – w_v->u) where u is child of node v, w_v->uis length of edge connecting node v and u and points[v] is the number points at the node v.
Now to find the maximum points of the path passing through the node v we calculate dp[u]-w_v->ufor each child of v and take the two biggest values from it and add points[v] in it.
If the maximum value of dp[u]-w_v->uis negative then we will take 0 instead of it.

Below is the implementation of the above approach:

C++

// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;
 
class GFG {
 
public:
    // Adjacency list to store the edges.
    vector<vector<pair<int, int> > > adj;
 
    // To store maximum points of a path
    // starting at a node
    vector<int> dp;
 
    // Visited vector to keep trackof nodes for
    // which dp values has already been calculated
    vector<int> vis;
 
    // To store the final answer
    int ans = 0;
 
    // Function for visiting every node and
    // calculating dp values for each node.
    void dfs(int curr_node, vector<int>& points)
    {
 
        // Mark the current node as visited so
        // that it does not have to be visited again.
        vis[curr_node] = 1;
 
        // To store maximum path starting
        // at node minus lenght of edge connecting
        // that node to current node for each
        // child of current node.
        vector<int> child_nodes;
 
        // Iterating through each child
        // of current node.
        for (auto x : adj[curr_node]) {
 
            // To check whether the child has been
            // already visited or not
            if (!vis[x.first]) {
 
                // Call dfs function for the child
                dfs(x.first, points);
            }
 
            // Push the value(maximum points path
            // starting at this child node minus lenght
            // of edge) into the vector
            child_nodes.push_back(dp[x.first] - x.second);
        }
 
        // Sort the vector in decreasing order
        // to pick 2 maximum 2 values.
        sort(child_nodes.begin(), child_nodes.end(),
             greater<int>());
 
        // max1-to store maximum points path
        // starting at child node of current
        // node, max2-to store second maximum
        // points path starting at child node
        // of current node.
        int max1 = 0, max2 = 0;
        if (child_nodes.size() >= 2) {
            max1 = max(max1, child_nodes[0]);
            max2 = max(max2, child_nodes[1]);
        }
        else if (child_nodes.size() >= 1) {
            max1 = max(max1, child_nodes[0]);
        }
 
        // Calculate maximum points path passing
        // through current node.
        ans = max(ans, max1 + max2 + points[curr_node]);
 
        // Store maximum points path starting
        // at current node in dp[curr_node]
        dp[curr_node] = max1 + points[curr_node];
    }
 
    // To find maximal points path
    int MaxPointPath(int n, vector<int> points,
                     vector<vector<int> > edges)
    {
        adj.resize(n + 1);
        dp.resize(n + 1);
        vis.resize(n + 1);
 
        // Filling adajency list
        for (int i = 0; i < n - 1; i++) {
            adj[edges[i][0]].push_back(
                { edges[i][1], edges[i][2] });
            adj[edges[i][1]].push_back(
                { edges[i][0], edges[i][0] });
        }
 
        // Calling dfs for node 1
        dfs(1, points);
 
        return ans;
    }
};
 
// Driver code
int main()
{
    GFG obj;
 
    // Number of Vertices
    int n = 5;
 
    // Points at each node
    vector<int> points(n + 1);
    points[1] = 6;
    points[2] = 3;
    points[3] = 2;
    points[4] = 5;
    points[5] = 0;
 
    // Edges and their lengths
    vector<vector<int> > edges{
        { 1, 2, 10 }, { 2, 3, 3 }, { 2, 4, 1 }, { 1, 5, 11 }
    };
 
    cout << obj.MaxPointPath(n, points, edges);
    return 0;
}

Java

import java.util.*;
 
class GFG {
    // Adjacency list to store the edges.
    List<List<AbstractMap.SimpleEntry<Integer, Integer>>> adj;
 
    // To store maximum points of a path starting at a node
    List<Integer> dp;
 
    // Visited vector to keep track of nodes for
    // which dp values have already been calculated
    List<Integer> vis;
 
    // To store the final answer
    int ans = 0;
 
    // Constructor
    GFG() {
        adj = new ArrayList<>();
        dp = new ArrayList<>();
        vis = new ArrayList<>();
    }
 
    // Function for visiting every node and calculating dp values for each node.
    void dfs(int currNode, List<Integer> points) {
        // Mark the current node as visited so that it does not have to be visited again.
        vis.set(currNode, 1);
 
        // To store maximum path starting at node minus length of edge connecting that node to the current node for each child of the current node.
        List<Integer> childNodes = new ArrayList<>();
 
        // Iterating through each child of the current node.
        for (AbstractMap.SimpleEntry<Integer, Integer> x : adj.get(currNode)) {
            // To check whether the child has been already visited or not
            if (vis.get(x.getKey()) == 0) {
                // Call dfs function for the child
                dfs(x.getKey(), points);
            }
 
            // Push the value (maximum points path starting at this child node minus length of the edge) into the vector
            childNodes.add(dp.get(x.getKey()) - x.getValue());
        }
 
        // Sort the vector in decreasing order to pick 2 maximum 2 values.
        Collections.sort(childNodes, Collections.reverseOrder());
 
        // max1 - to store the maximum points path starting at the child node of the current node, max2 - to store the second maximum points path starting at the child node of the current node.
        int max1 = 0, max2 = 0;
        if (childNodes.size() >= 2) {
            max1 = Math.max(max1, childNodes.get(0));
            max2 = Math.max(max2, childNodes.get(1));
        } else if (childNodes.size() == 1) {
            max1 = Math.max(max1, childNodes.get(0));
        }
 
        // Calculate maximum points path passing through the current node.
        ans = Math.max(ans, max1 + max2 + points.get(currNode));
 
        // Store the maximum points path starting at the current node in dp[currNode]
        dp.set(currNode, max1 + points.get(currNode));
    }
 
    // To find the maximal points path
    int maxPointPath(int n, List<Integer> points, List<List<Integer>> edges) {
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
            dp.add(0);
            vis.add(0);
        }
 
        // Filling the adjacency list
        for (List<Integer> edge : edges) {
            adj.get(edge.get(0)).add(new AbstractMap.SimpleEntry<>(edge.get(1), edge.get(2)));
            adj.get(edge.get(1)).add(new AbstractMap.SimpleEntry<>(edge.get(0), edge.get(2)));
        }
 
        // Calling dfs for node 1
        dfs(1, points);
 
        return ans;
    }
 
    // Driver code
    public static void main(String[] args) {
        GFG obj = new GFG();
 
        // Number of Vertices
        int n = 5;
 
        // Points at each node
        List<Integer> points = new ArrayList<>();
        points.add(0); // Adding an extra element at index 0 for simplicity
        points.add(6);
        points.add(3);
        points.add(2);
        points.add(5);
        points.add(0);
 
        // Edges and their lengths
        List<List<Integer>> edges = Arrays.asList(
                Arrays.asList(1, 2, 10),
                Arrays.asList(2, 3, 3),
                Arrays.asList(2, 4, 1),
                Arrays.asList(1, 5, 11)
        );
 
        System.out.println(obj.maxPointPath(n, points, edges));
    }
}

Python3

# Python Code Implementation
class GFG:
    def __init__(self):
        # Adjacency list to store the edges.
        self.adj = []
 
        # To store maximum points of a path 
        #starting at a node
        self.dp = []
 
        # Visited vector to keep track of nodes 
        #for which dp values has already been calculated
        self.vis = []
 
        # To store the final answer
        self.ans = 0
 
    # Function for visiting every node and 
    #calculating dp values for each node.
    def dfs(self, curr_node, points):
        # Mark the current node as visited so 
        # that it does not have to be visited again.
        self.vis[curr_node] = 1
 
        # To store maximum path starting at node 
        # minus length of edge connecting that node to 
        # current node for each child of current node.
        child_nodes = []
 
        # Iterating through each child of current node.
        for x in self.adj[curr_node]:
           
            # To check whether the child 
            # has been already visited or not
            if not self.vis[x[0]]:
               
                # Call dfs function for the child
                self.dfs(x[0], points)
 
            # Push the value(maximum points path 
            # starting at this child node minus length of edge) 
            # into the vector
            child_nodes.append(self.dp[x[0]] - x[1])
 
        # Sort the vector in decreasing 
        # order to pick 2 maximum values.
        child_nodes.sort(reverse=True)
 
        # max1-to store maximum points path starting 
        # at child node of current node, max2-to store 
        # second maximum points path starting at 
        # child node of current node.
        max1 = 0
        max2 = 0
        if len(child_nodes) >= 2:
            max1 = max(max1, child_nodes[0])
            max2 = max(max2, child_nodes[1])
        elif len(child_nodes) >= 1:
            max1 = max(max1, child_nodes[0])
 
        # Calculate maximum points path 
        # passing through current node.
        self.ans = max(self.ans, max1 + max2 + points[curr_node])
 
        # Store maximum points path starting 
        # at current node in dp[curr_node]
        self.dp[curr_node] = max1 + points[curr_node]
 
    # To find maximal points path
    def MaxPointPath(self, n, points, edges):
        self.adj = [[] for _ in range(n + 1)]
        self.dp = [0] * (n + 1)
        self.vis = [0] * (n + 1)
 
        # Filling adjacency list
        for i in range(n - 1):
            self.adj[edges[i][0]].append((edges[i][1], edges[i][2]))
            self.adj[edges[i][1]].append((edges[i][0], edges[i][2]))
 
        # Calling dfs for node 1
        self.dfs(1, points)
 
        return self.ans
 
 
# Driver code
if __name__ == "__main__":
    obj = GFG()
 
    # Number of Vertices
    n = 5
 
    # Points at each node
    points = [0, 6, 3, 2, 5, 0]
 
    # Edges and their lengths
    edges = [
        [1, 2, 10],
        [2, 3, 3],
        [2, 4, 1],
        [1, 5, 11]
    ]
 
    print(obj.MaxPointPath(n, points, edges))
 
# This code is contributed by Sakshi

C#

//C# code for the above approach
using System;
using System.Collections.Generic;
using System.Linq;
 
class GFG
{
    // Adjacency list to store the edges.
    List<List<Tuple<int, int>>> adj = new List<List<Tuple<int, int>>>();
 
    // To store maximum points of a path
    // starting at a node
    List<int> dp = new List<int>();
 
    // Visited vector to keep track of nodes for
    // which dp values have already been calculated
    List<bool> vis = new List<bool>();
 
    // To store the final answer
    int ans = 0;
 
    // Function for visiting every node and
    // calculating dp values for each node.
    void dfs(int currNode, List<int> points)
    {
        // Mark the current node as visited so
        // that it does not have to be visited again.
        vis[currNode] = true;
 
        // To store maximum path starting
        // at node minus length of edge connecting
        // that node to the current node for each
        // child of the current node.
        List<int> childNodes = new List<int>();
 
        // Iterating through each child
        // of the current node.
        foreach (var edge in adj[currNode])
        {
            int childNode = edge.Item1;
            int edgeLength = edge.Item2;
 
            // To check whether the child has been
            // already visited or not
            if (!vis[childNode])
            {
                // Call dfs function for the child
                dfs(childNode, points);
            }
 
            // Push the value (maximum points path
            // starting at this child node minus length
            // of edge) into the list
            childNodes.Add(dp[childNode] - edgeLength);
        }
 
        // Sort the list in decreasing order
        // to pick the maximum 2 values.
        childNodes.Sort((a, b) => b.CompareTo(a));
 
        // max1 - to store maximum points path
        // starting at a child node of the current
        // node, max2 - to store the second maximum
        // points path starting at a child node
        // of the current node.
        int max1 = 0, max2 = 0;
        if (childNodes.Count >= 2)
        {
            max1 = Math.Max(max1, childNodes[0]);
            max2 = Math.Max(max2, childNodes[1]);
        }
        else if (childNodes.Count >= 1)
        {
            max1 = Math.Max(max1, childNodes[0]);
        }
 
        // Calculate maximum points path passing
        // through the current node.
        ans = Math.Max(ans, max1 + max2 + points[currNode]);
 
        // Store the maximum points path starting
        // at the current node in dp[currNode]
        dp[currNode] = max1 + points[currNode];
    }
 
    // To find the maximal points path
    int MaxPointPath(int n, List<int> points, List<List<int>> edges)
    {
        adj = new List<List<Tuple<int, int>>>(n + 1);
        dp = new List<int>(n + 1);
        vis = new List<bool>(n + 1);
 
        for (int i = 0; i <= n; i++)
        {
            adj.Add(new List<Tuple<int, int>>());
            dp.Add(0);
            vis.Add(false);
        }
 
        // Filling adjacency list
        foreach (var edge in edges)
        {
            int u = edge[0];
            int v = edge[1];
            int w = edge[2];
            adj[u].Add(new Tuple<int, int>(v, w));
            adj[v].Add(new Tuple<int, int>(u, w));
        }
 
        // Calling dfs for node 1
        dfs(1, points);
 
        return ans;
    }
 
    static void Main()
    {
        GFG obj = new GFG();
 
        // Number of Vertices
        int n = 5;
 
        // Points at each node
        List<int> points = new List<int>(n + 1)
        {
            0, 6, 3, 2, 5, 0
        };
 
        // Edges and their lengths
        List<List<int>> edges = new List<List<int>>
        {
            new List<int> { 1, 2, 10 },
            new List<int> { 2, 3, 3 },
            new List<int> { 2, 4, 1 },
            new List<int> { 1, 5, 11 }
        };
 
        Console.WriteLine(obj.MaxPointPath(n, points, edges));
    }
}

Javascript

// Javascript code for the above approach
 
class GFG {
    constructor() {
        // Adjacency list to store the edges.
        this.adj = [];
 
        // To store maximum points of a path
        // starting at a node
        this.dp = [];
 
        // Visited vector to keep track of nodes for
        // which dp values have already been calculated
        this.vis = [];
 
        // To store the final answer
        this.ans = 0;
    }
 
    // Function for visiting every node and
    // calculating dp values for each node.
    dfs(currNode, points) {
        // Mark the current node as visited so
        // that it does not have to be visited again.
        this.vis[currNode] = 1;
 
        // To store maximum path starting
        // at node minus length of edge connecting
        // that node to the current node for each
        // child of the current node.
        const childNodes = [];
 
        // Iterating through each child
        // of the current node.
        for (const [child, edgeLength] of this.adj[currNode]) {
            // To check whether the child has been
            // already visited or not
            if (!this.vis[child]) {
                // Call dfs function for the child
                this.dfs(child, points);
            }
 
            // Push the value (maximum points path
            // starting at this child node minus length
            // of the edge) into the vector
            childNodes.push(this.dp[child] - edgeLength);
        }
 
        // Sort the vector in decreasing order
        // to pick 2 maximum values.
        childNodes.sort((a, b) => b - a);
 
        // max1 - to store maximum points path
        // starting at the child node of the current
        // node, max2 - to store second maximum
        // points path starting at the child node
        // of the current node.
        let max1 = 0,
            max2 = 0;
        if (childNodes.length >= 2) {
            max1 = Math.max(max1, childNodes[0]);
            max2 = Math.max(max2, childNodes[1]);
        } else if (childNodes.length >= 1) {
            max1 = Math.max(max1, childNodes[0]);
        }
 
        // Calculate maximum points path passing
        // through the current node.
        this.ans = Math.max(this.ans, max1 + max2 + points[currNode]);
 
        // Store maximum points path starting
        // at the current node in dp[currNode]
        this.dp[currNode] = max1 + points[currNode];
    }
 
    // To find maximal points path
    MaxPointPath(n, points, edges) {
        this.adj = Array(n + 1).fill().map(() => []);
        this.dp = Array(n + 1).fill(0);
        this.vis = Array(n + 1).fill(0);
 
        // Filling adjacency list
        for (let i = 0; i < n - 1; i++) {
            this.adj[edges[i][0]].push([edges[i][1], edges[i][2]]);
            this.adj[edges[i][1]].push([edges[i][0], edges[i][2]]);
        }
 
        // Calling dfs for node 1
        this.dfs(1, points);
 
        return this.ans;
    }
}
 
// Driver code
const obj = new GFG();
 
// Number of Vertices
const n = 5;
 
// Points at each node
const points = [0, 6, 3, 2, 5, 0];
 
// Edges and their lengths
const edges = [
    [1, 2, 10],
    [2, 3, 3],
    [2, 4, 1],
    [1, 5, 11]
];
 
console.log(obj.MaxPointPath(n, points, edges));
 
// This code is contributed by ragul21

Output

Time Complexity: O(n*logn), since for each node sorting is performed on the values of its children.
Auxiliary Space : O(n), where n is the number of nodes in the tree.

Elevate your coding journey with a Premium subscription. Benefit from ad-free learning, unlimited article summaries, an AI bot, access to 35+ courses, and more-available only with GeeksforGeeks Premium! Explore now!

Reffered: https://www.geeksforgeeks.org

DSA

Related
Lexicographically minimum String possible
Ascending insertion of elements in graph
Inserting Elements in an Array \| Array Operations
Count unvisited leaves after Frog Jumps
Minimum number of operations to make all letters in the string equal

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	15