GFG App
Open App
Browser
Continue

Length of Longest increasing sequence of nodes in a given Graph

Given a graph root, the task is to find the length of the longest increasing sequence in the graph.

Example:

Input:   root =     7—-17
/    \
1—-2—-5      4
/          \      \
11           6—-8
/
12
Output: 6
Explanation: The longest increasing sequence in the graph consists of the nodes 1, 2, 5, 6, 8, 12

Input:   2
/  \
3     1
/         \
5           6
Output: 4

Approach: The given problem can be solved by using the depth-first search on every node in the graph. The idea is to use recursion and visit the neighbor nodes with values less than the current node and calculate the longest path ending up to the neighbors before calculating the longest path ending up to the current node. Below steps can be followed to solve the problem:

• Apply depth-first search on the root node to visit and store all the nodes in a list
• Use recursion to apply depth-first search on every unvisited node of the graph and use a hashmap to store the visited nodes of the graph mapping to the longest path ending up to that node
• At every node iterate through the ArrayList of neighbors and use recursion on the neighbor nodes with a value less than the current node’s value and calculate the longest path ending at them
• Find the maximum of the longest path ending up to the neighbors and add 1 to it for calculating the longest path ending up to the current node
• Return the maximum of all longest paths

Below is the implementation of the above approach:

C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `class` `Node {` `public``:` `    ``vector neighbors;` `    ``int` `val;`   `    ``// constructor` `    ``Node(``int` `v)` `    ``{`   `        ``val = v;` `        ``neighbors = {};` `    ``}` `};`   `// Depth first search function to add` `// every node of the graph in a list` `void` `dfs(Node* root, unordered_map& visited,` `         ``vector& nodes)` `{`   `    ``// If the current node is` `    ``// already visited then return` `    ``if` `(visited.find(root) != visited.end())` `        ``return``;`   `    ``// Mark the current node as visited` `    ``visited[root] = 0;`   `    ``// Add the current node in the list` `    ``nodes.push_back(root);`   `    ``// Iterate through all neighbors` `    ``for` `(Node* n : root->neighbors) {`   `        ``// Visit the neighbors` `        ``dfs(n, visited, nodes);` `    ``}` `}` `// Depth first search function` `// to calculate the longest path` `// ending at every node` `int` `findLongestPath(Node* root,` `                    ``unordered_map& visited)` `{`   `    ``// If the current node is visited` `    ``// then return its value` `    ``if` `(visited[root] > 0)` `        ``return` `visited[root];`   `    ``// Initialize a variable max to` `    ``// calculate longest increasing path` `    ``int` `maxi = 0;`   `    ``// Iterate through all neighbors` `    ``for` `(Node* n : root->neighbors) {`   `        ``// If neighbor's value is less` `        ``// than current node's value then` `        ``// find longest path ending up to` `        ``// the neighbor` `        ``if` `(n->val < root->val) {`   `            ``// Update max` `            ``maxi = max(maxi, findLongestPath(n, visited));` `        ``}` `    ``}`   `    ``// Store the value in the hashmap` `    ``visited[root] = maxi + 1;`   `    ``// Return the longest increasing` `    ``// path ending on root` `    ``return` `maxi + 1;` `}` `// Function to find the longest` `// increasing path in a graph` `int` `longestIncPath(Node* root)` `{`   `    ``// Base case` `    ``if` `(root == NULL)` `        ``return` `0;`   `    ``// Initialize a variable max` `    ``// to calculate longest path` `    ``int` `maxi = 1;`   `    ``// Initialize a HashMap to` `    ``// store the visited nodes` `    ``unordered_map visited;`   `    ``// List to store all the` `    ``// nodes in a graph` `    ``vector nodes;`   `    ``// Apply DFS on the graph` `    ``// add all the nodes in a list` `    ``dfs(root, visited, nodes);`   `    ``// Iterate through the list of nodes` `    ``for` `(``int` `i = 0; i < nodes.size(); i++) {`   `        ``Node* curr = nodes[i];`   `        ``// Current node is not already visited` `        ``if` `(visited[curr] == 0) {`   `            ``// Apply DFS to find the` `            ``// longest path ending on` `            ``// the current node` `            ``findLongestPath(curr, visited);` `        ``}`   `        ``// Update max by comparing it` `        ``// with the longest path ending` `        ``// on the current node` `        ``maxi = max(maxi, visited[curr]);` `    ``}`   `    ``// Return the answer` `    ``return` `maxi;` `}`   `// Driver code` `int` `main()` `{`   `    ``// Initialize the graph` `    ``Node* seven = ``new` `Node(7);` `    ``Node* five = ``new` `Node(5);` `    ``Node* four = ``new` `Node(4);` `    ``Node* seventeen = ``new` `Node(17);` `    ``Node* one = ``new` `Node(1);` `    ``Node* two = ``new` `Node(2);` `    ``Node* six = ``new` `Node(6);` `    ``Node* eight = ``new` `Node(8);` `    ``Node* eleven = ``new` `Node(11);` `    ``Node* twelve = ``new` `Node(12);` `    ``one->neighbors.push_back(two);` `    ``eleven->neighbors.push_back(two);` `    ``two->neighbors.push_back(one);` `    ``two->neighbors.push_back(eleven);` `    ``two->neighbors.push_back(five);` `    ``eight->neighbors.push_back(twelve);` `    ``eight->neighbors.push_back(six);` `    ``eight->neighbors.push_back(four);` `    ``four->neighbors.push_back(eight);` `    ``four->neighbors.push_back(seven);` `    ``twelve->neighbors.push_back(eight);` `    ``six->neighbors.push_back(five);` `    ``six->neighbors.push_back(eight);` `    ``five->neighbors.push_back(two);` `    ``five->neighbors.push_back(seven);` `    ``five->neighbors.push_back(six);` `    ``seven->neighbors.push_back(five);` `    ``seven->neighbors.push_back(four);` `    ``seven->neighbors.push_back(seventeen);` `    ``seventeen->neighbors.push_back(seven);`   `    ``// Call the function` `    ``// and print the result` `    ``cout << (longestIncPath(seven));` `    ``return` `0;` `}`   `// This code is contributed by Potta Lokesh`

Java

 `// Java implementation for the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``static` `class` `Node {`   `        ``List neighbors;` `        ``int` `val;`   `        ``// constructor` `        ``public` `Node(``int` `val)` `        ``{`   `            ``this``.val = val;` `            ``neighbors = ``new` `ArrayList<>();` `        ``}` `    ``}`   `    ``// Function to find the longest` `    ``// increasing path in a graph` `    ``public` `static` `int` `longestIncPath(Node root)` `    ``{`   `        ``// Base case` `        ``if` `(root == ``null``)` `            ``return` `0``;`   `        ``// Initialize a variable max` `        ``// to calculate longest path` `        ``int` `max = ``1``;`   `        ``// Initialize a HashMap to` `        ``// store the visited nodes` `        ``Map visited = ``new` `HashMap<>();`   `        ``// List to store all the` `        ``// nodes in a graph` `        ``List nodes = ``new` `ArrayList<>();`   `        ``// Apply DFS on the graph` `        ``// add all the nodes in a list` `        ``dfs(root, visited, nodes);`   `        ``// Iterate through the list of nodes` `        ``for` `(``int` `i = ``0``; i < nodes.size(); i++) {`   `            ``Node curr = nodes.get(i);`   `            ``// Current node is not already visited` `            ``if` `(visited.get(curr) == ``0``) {`   `                ``// Apply DFS to find the` `                ``// longest path ending on` `                ``// the current node` `                ``findLongestPath(curr, visited);` `            ``}`   `            ``// Update max by comparing it` `            ``// with the longest path ending` `            ``// on the current node` `            ``max = Math.max(max, visited.get(curr));` `        ``}`   `        ``// Return the answer` `        ``return` `max;` `    ``}`   `    ``// Depth first search function` `    ``// to calculate the longest path` `    ``// ending at every node` `    ``public` `static` `int` `    ``findLongestPath(Node root, Map visited)` `    ``{`   `        ``// If the current node is visited` `        ``// then return its value` `        ``if` `(visited.get(root) > ``0``)` `            ``return` `visited.get(root);`   `        ``// Initialize a variable max to` `        ``// calculate longest increasing path` `        ``int` `max = ``0``;`   `        ``// Iterate through all neighbors` `        ``for` `(Node n : root.neighbors) {`   `            ``// If neighbor's value is less` `            ``// than current node's value then` `            ``// find longest path ending up to` `            ``// the neighbor` `            ``if` `(n.val < root.val) {`   `                ``// Update max` `                ``max = Math.max(max,` `                               ``findLongestPath(n, visited));` `            ``}` `        ``}`   `        ``// Store the value in the hashmap` `        ``visited.put(root, max + ``1``);`   `        ``// Return the longest increasing` `        ``// path ending on root` `        ``return` `max + ``1``;` `    ``}`   `    ``// Depth first search function to add` `    ``// every node of the graph in a list` `    ``public` `static` `void` `dfs(Node root,` `                           ``Map visited,` `                           ``List nodes)` `    ``{`   `        ``// If the current node is` `        ``// already visited then return` `        ``if` `(visited.containsKey(root))` `            ``return``;`   `        ``// Mark the current node as visited` `        ``visited.put(root, ``0``);`   `        ``// Add the current node in the list` `        ``nodes.add(root);`   `        ``// Iterate through all neighbors` `        ``for` `(Node n : root.neighbors) {`   `            ``// Visit the neighbors` `            ``dfs(n, visited, nodes);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Initialize the graph` `        ``Node seven = ``new` `Node(``7``);` `        ``Node five = ``new` `Node(``5``);` `        ``Node four = ``new` `Node(``4``);` `        ``Node seventeen = ``new` `Node(``17``);` `        ``Node one = ``new` `Node(``1``);` `        ``Node two = ``new` `Node(``2``);` `        ``Node six = ``new` `Node(``6``);` `        ``Node eight = ``new` `Node(``8``);` `        ``Node eleven = ``new` `Node(``11``);` `        ``Node twelve = ``new` `Node(``12``);` `        ``one.neighbors.add(two);` `        ``eleven.neighbors.add(two);` `        ``two.neighbors.add(one);` `        ``two.neighbors.add(eleven);` `        ``two.neighbors.add(five);` `        ``eight.neighbors.add(twelve);` `        ``eight.neighbors.add(six);` `        ``eight.neighbors.add(four);` `        ``four.neighbors.add(eight);` `        ``four.neighbors.add(seven);` `        ``twelve.neighbors.add(eight);` `        ``six.neighbors.add(five);` `        ``six.neighbors.add(eight);` `        ``five.neighbors.add(two);` `        ``five.neighbors.add(seven);` `        ``five.neighbors.add(six);` `        ``seven.neighbors.add(five);` `        ``seven.neighbors.add(four);` `        ``seven.neighbors.add(seventeen);` `        ``sevTeen.neighbors.add(seven);`   `        ``// Call the function` `        ``// and print the result` `        ``System.out.println(longestIncPath(seven));` `    ``}` `}`

C#

 `// C# implementation for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `    ``class` `Node {`   `        ``public` `List neighbors;` `        ``public` `int` `val;`   `        ``// constructor` `        ``public` `Node(``int` `val)` `        ``{`   `            ``this``.val = val;` `            ``neighbors = ``new` `List();` `        ``}` `    ``}`   `    ``// Function to find the longest` `    ``// increasing path in a graph` `    ``static` `int` `longestIncPath(Node root)` `    ``{`   `        ``// Base case` `        ``if` `(root == ``null``)` `            ``return` `0;`   `        ``// Initialize a variable max` `        ``// to calculate longest path` `        ``int` `max = 1;`   `        ``// Initialize a Dictionary to` `        ``// store the visited nodes` `        ``Dictionary visited` `            ``= ``new` `Dictionary();`   `        ``// List to store all the` `        ``// nodes in a graph` `        ``List nodes = ``new` `List();`   `        ``// Apply DFS on the graph` `        ``// add all the nodes in a list` `        ``dfs(root, visited, nodes);`   `        ``// Iterate through the list of nodes` `        ``for` `(``int` `i = 0; i < nodes.Count; i++) {`   `            ``Node curr = nodes[i];`   `            ``// Current node is not already visited` `            ``if` `(visited[curr] == 0) {`   `                ``// Apply DFS to find the` `                ``// longest path ending on` `                ``// the current node` `                ``findlongestPath(curr, visited);` `            ``}`   `            ``// Update max by comparing it` `            ``// with the longest path ending` `            ``// on the current node` `            ``max = Math.Max(max, visited[curr]);` `        ``}`   `        ``// Return the answer` `        ``return` `max;` `    ``}`   `    ``// Depth first search function` `    ``// to calculate the longest path` `    ``// ending at every node` `    ``static` `int` `    ``findlongestPath(Node root,` `                    ``Dictionary visited)` `    ``{`   `        ``// If the current node is visited` `        ``// then return its value` `        ``if` `(visited[root] > 0)` `            ``return` `visited[root];`   `        ``// Initialize a variable max to` `        ``// calculate longest increasing path` `        ``int` `max = 0;`   `        ``// Iterate through all neighbors` `        ``foreach``(Node n ``in` `root.neighbors)` `        ``{`   `            ``// If neighbor's value is less` `            ``// than current node's value then` `            ``// find longest path ending up to` `            ``// the neighbor` `            ``if` `(n.val < root.val) {`   `                ``// Update max` `                ``max = Math.Max(max,` `                               ``findlongestPath(n, visited));` `            ``}` `        ``}`   `        ``// Store the value in the hashmap` `        ``if` `(visited.ContainsKey(root))` `            ``visited[root] = max + 1;` `        ``else` `            ``visited.Add(root, max + 1);`   `        ``// Return the longest increasing` `        ``// path ending on root` `        ``return` `max + 1;` `    ``}`   `    ``// Depth first search function to add` `    ``// every node of the graph in a list` `    ``static` `void` `dfs(Node root,` `                    ``Dictionary visited,` `                    ``List nodes)` `    ``{`   `        ``// If the current node is` `        ``// already visited then return` `        ``if` `(visited.ContainsKey(root))` `            ``return``;`   `        ``// Mark the current node as visited` `        ``visited.Add(root, 0);`   `        ``// Add the current node in the list` `        ``nodes.Add(root);`   `        ``// Iterate through all neighbors` `        ``foreach``(Node n ``in` `root.neighbors)` `        ``{`   `            ``// Visit the neighbors` `            ``dfs(n, visited, nodes);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// Initialize the graph` `        ``Node seven = ``new` `Node(7);` `        ``Node five = ``new` `Node(5);` `        ``Node four = ``new` `Node(4);` `        ``Node seventeen = ``new` `Node(17);` `        ``Node one = ``new` `Node(1);` `        ``Node two = ``new` `Node(2);` `        ``Node six = ``new` `Node(6);` `        ``Node eight = ``new` `Node(8);` `        ``Node eleven = ``new` `Node(11);` `        ``Node twelve = ``new` `Node(12);` `        ``one.neighbors.Add(two);` `        ``eleven.neighbors.Add(two);` `        ``two.neighbors.Add(one);` `        ``two.neighbors.Add(eleven);` `        ``two.neighbors.Add(five);` `        ``eight.neighbors.Add(twelve);` `        ``eight.neighbors.Add(six);` `        ``eight.neighbors.Add(four);` `        ``four.neighbors.Add(eight);` `        ``four.neighbors.Add(seven);` `        ``twelve.neighbors.Add(eight);` `        ``six.neighbors.Add(five);` `        ``six.neighbors.Add(eight);` `        ``five.neighbors.Add(two);` `        ``five.neighbors.Add(seven);` `        ``five.neighbors.Add(six);` `        ``seven.neighbors.Add(five);` `        ``seven.neighbors.Add(four);` `        ``seven.neighbors.Add(seventeen);` `        ``seventeen.neighbors.Add(seven);`   `        ``// Call the function` `        ``// and print the result` `        ``Console.WriteLine(longestIncPath(seven));` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

Javascript

 `// Javascript code for the above approach`   `class Node {` `  ``// constructor` `  ``constructor(v) {`   `    ``this``.val = v;` `    ``this``.neighbors = [];` `  ``}` `};`   `// Depth first search function to add` `// every node of the graph in a list` `function` `dfs(root, visited, nodes) {`   `  ``// If the current node is` `  ``// already visited then return` `  ``if` `(visited.has(root))` `    ``return``;`   `  ``// Mark the current node as visited` `  ``visited.set(root, 0);`   `  ``// Add the current node in the list` `  ``nodes.push(root);`   `  ``// Iterate through all neighbors` `  ``for` `(n of root.neighbors) {`   `    ``// Visit the neighbors` `    ``dfs(n, visited, nodes);` `  ``}` `}` `// Depth first search function` `// to calculate the longest path` `// ending at every node` `function` `findLongestPath(root, visited) {`   `  ``// If the current node is visited` `  ``// then return its value` `  ``if` `(visited.get(root) > 0)` `    ``return` `visited.get(root);`   `  ``// Initialize a variable max to` `  ``// calculate longest increasing path` `  ``let maxi = 0;`   `  ``// Iterate through all neighbors` `  ``for` `(n of root.neighbors) {`   `    ``// If neighbor's value is less` `    ``// than current node's value then` `    ``// find longest path ending up to` `    ``// the neighbor` `    ``if` `(n.val < root.val) {`   `      ``// Update max` `      ``maxi = Math.max(` `        ``maxi,` `        ``findLongestPath(n, visited));` `    ``}` `  ``}`   `  ``// Store the value in the hashmap` `  ``visited.set(root, maxi + 1);`   `  ``// Return the longest increasing` `  ``// path ending on root` `  ``return` `maxi + 1;` `}` `// Function to find the longest` `// increasing path in a graph` `function` `longestIncPath(root) {`   `  ``// Base case` `  ``if` `(root == ``null``)` `    ``return` `0;`   `  ``// Initialize a variable max` `  ``// to calculate longest path` `  ``let maxi = 1;`   `  ``// Initialize a HashMap to` `  ``// store the visited nodes` `  ``let visited = ``new` `Map();`   `  ``// List to store all the` `  ``// nodes in a graph` `  ``let nodes = [];`   `  ``// Apply DFS on the graph` `  ``// add all the nodes in a list` `  ``dfs(root, visited, nodes);`   `  ``// Iterate through the list of nodes` `  ``for` `(let i = 0; i < nodes.length; i++) {`   `    ``let curr = nodes[i];`   `    ``// Current node is not already visited` `    ``if` `(visited.get(curr) == 0) {`   `      ``// Apply DFS to find the` `      ``// longest path ending on` `      ``// the current node` `      ``findLongestPath(curr, visited);` `    ``}`   `    ``// Update max by comparing it` `    ``// with the longest path ending` `    ``// on the current node` `    ``maxi = Math.max(` `      ``maxi, visited.get(curr));` `  ``}`   `  ``// Return the answer` `  ``return` `maxi;` `}`   `// Driver code`     `// Initialize the graph` `let seven = ``new` `Node(7);` `let five = ``new` `Node(5);` `let four = ``new` `Node(4);` `let seventeen = ``new` `Node(17);` `let one = ``new` `Node(1);` `let two = ``new` `Node(2);` `let six = ``new` `Node(6);` `let eight = ``new` `Node(8);` `let eleven = ``new` `Node(11);` `let twelve = ``new` `Node(12);` `one.neighbors.push(two);` `eleven.neighbors.push(two);` `two.neighbors.push(one);` `two.neighbors.push(eleven);` `two.neighbors.push(five);` `eight.neighbors.push(twelve);` `eight.neighbors.push(six);` `eight.neighbors.push(four);` `four.neighbors.push(eight);` `four.neighbors.push(seven);` `twelve.neighbors.push(eight);` `six.neighbors.push(five);` `six.neighbors.push(eight);` `five.neighbors.push(two);` `five.neighbors.push(seven);` `five.neighbors.push(six);` `seven.neighbors.push(five);` `seven.neighbors.push(four);` `seven.neighbors.push(seventeen);` `seventeen.neighbors.push(seven);`   `// Call the function` `// and print the result` `document.write((longestIncPath(seven)));`   `// This code is contributed by saurabh_jaiswal.`

Python3

 `from` `typing ``import` `List`     `class` `Node:` `    ``def` `__init__(``self``, v):` `        ``self``.neighbors ``=` `[]` `        ``self``.val ``=` `v`     `def` `dfs(root: Node, visited: ``dict``, nodes: ``List``[Node]) ``-``> ``None``:` `    ``if` `root ``in` `visited:` `        ``return` `    ``visited[root] ``=` `0` `    ``nodes.append(root)` `    ``for` `n ``in` `root.neighbors:` `        ``dfs(n, visited, nodes)`     `def` `findLongestPath(root: Node, visited: ``dict``) ``-``> ``int``:` `    ``if` `root ``in` `visited ``and` `visited[root] > ``0``:` `        ``return` `visited[root]` `    ``maxi ``=` `0` `    ``for` `n ``in` `root.neighbors:` `        ``if` `n.val < root.val:` `            ``maxi ``=` `max``(maxi, findLongestPath(n, visited))` `    ``visited[root] ``=` `maxi ``+` `1` `    ``return` `maxi ``+` `1`     `def` `longestIncPath(root: Node) ``-``> ``int``:` `    ``if` `root ``is` `None``:` `        ``return` `0` `    ``maxi ``=` `1` `    ``visited ``=` `{}` `    ``nodes ``=` `[]` `    ``dfs(root, visited, nodes)` `    ``for` `curr ``in` `nodes:` `        ``if` `visited[curr] ``=``=` `0``:` `            ``findLongestPath(curr, visited)` `        ``maxi ``=` `max``(maxi, visited[curr])` `    ``return` `maxi`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``seven ``=` `Node(``7``)` `    ``five ``=` `Node(``5``)` `    ``four ``=` `Node(``4``)` `    ``seventeen ``=` `Node(``17``)` `    ``one ``=` `Node(``1``)` `    ``two ``=` `Node(``2``)` `    ``six ``=` `Node(``6``)` `    ``eight ``=` `Node(``8``)` `    ``eleven ``=` `Node(``11``)` `    ``twelve ``=` `Node(``12``)` `    ``one.neighbors.append(two)` `    ``eleven.neighbors.append(two)` `    ``two.neighbors.extend([one, eleven, five])` `    ``eight.neighbors.extend([twelve, six, four])` `    ``four.neighbors.extend([eight, seven])` `    ``twelve.neighbors.append(eight)` `    ``six.neighbors.extend([five, eight])` `    ``five.neighbors.extend([two, seven, six])` `    ``seven.neighbors.extend([five, four, seventeen])` `    ``seventeen.neighbors.append(seven)` `    ``print``(longestIncPath(seven))`   `# This code is contributed by Akash Jha`

Output

`6`

Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges
Auxiliary Space: O(V)

My Personal Notes arrow_drop_up