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] – wv->u ) where u is child of node v, wv->u is 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]-wv->u for 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]-wv->u is negative then we will take 0 instead of it.
Below is the implementation of the above approach:
// 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;
} |
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));
}
} |
# 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# 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 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 |
7
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.