# Solution For Longest Cycle In A Graph

Problem Statement:

Given an undirected graph, find the length of the longest cycle in the graph.

Example:

Input:
graph = [[1,2], [2,3], [3,4], [4,5], [5,6], [6,1]] Output:
6

Explanation:
The given graph has a cycle of length 6 which is [1,2,3,4,5,6].

Solution:

To solve this problem, we can use the Depth First Search (DFS) algorithm to explore the graph and detect cycles in it.

Algorithm:

1. Initialize a variable max_cycle_length to 0.
2. For each node in the graph, perform a DFS starting from that node and calculate the maximum length of the cycle found.
3. If the length of the cycle found is greater than max_cycle_length, update max_cycle_length with the new value.
4. Return the value of max_cycle_length.

In the DFS algorithm, we need to keep track of the visited nodes and the parent node of each node to detect cycles.

Algorithm for DFS:

1. Initialize a visited array to keep track of the visited nodes and a parent array to keep track of the parent node of each node.
2. For each unvisited node, perform a DFS starting from that node.
3. In the DFS function, mark the current node as visited and iterate over all its neighbors.
4. If a neighbor is not visited, set its parent to the current node and recursively call the DFS function on it.
5. If a neighbor is visited and its parent is not the current node, it means that a cycle is found. In this case, calculate the length of the cycle by counting the number of nodes from the current node to the neighbor node and return it.
6. If a neighbor is visited and its parent is the current node, it means that we are backtracking and there is no cycle. In this case, return 0.

Python Code:

class Solution:
def maxCycleLength(self, graph: List[List[int]]) -> int:
n = len(graph)
max_cycle_length = 0

``````    def dfs(node, parent, visited):
visited[node] = True
for neighbor in graph[node]:
if not visited[neighbor]:
parent[neighbor] = node
cycle_length = dfs(neighbor, parent, visited)
if cycle_length > 0:
return cycle_length + 1
elif neighbor != parent[node]:
return 2

return 0

for i in range(n):
visited = [False] * n
parent = [-1] * n
cycle_length = dfs(i, parent, visited)
max_cycle_length = max(max_cycle_length, cycle_length)

return max_cycle_length
``````

Time Complexity:

The time complexity of the DFS algorithm is O(E+V) where E is the number of edges and V is the number of vertices in the graph. We perform a DFS for each node, so the overall time complexity of the solution is O(V*(E+V)).

Space Complexity:

The space complexity of the DFS function is O(V) for the visited and parent arrays. We call the DFS function V times, so the overall space complexity of the solution is O(V^2).

## Step by Step Implementation For Longest Cycle In A Graph

```There are many possible solutions to this problem. One approach is to use a depth-first search algorithm to find the longest path through the graph. The code for this solution is provided below.

//DFS function to find the longest path in a graph
public int findLongestPath(int[][] graph, int start, int end, int length, int max) {
//if we've reached the end of the graph, return the length
if(start == end) {
return length;
}
//mark the current node as visited
graph[start][end] = 1;
//try all possible paths from the current node
for(int i = 0; i < graph.length; i++) {
if(graph[start][i] == 1) {
//if the path has not been visited yet, recurse
int newLength = findLongestPath(graph, i, end, length+1, max);
//update the max length if necessary
if(newLength > max) {
max = newLength;
}
}
}
//unmark the current node
graph[start][end] = 0;
return max;
}```
```This is a Python implementation of a solution to the leetcode problem longest-cycle-in-a-graph. The code is commented to explain the algorithm and implementation.

def longest_cycle(graph):
"""
Given a graph, find the length of the longest cycle in the graph.
"""

# Initialize a dictionary to keep track of the lengths of the
# cycles we find. The dictionary key will be the starting node
# of the cycle and the value will be the length of the cycle.
cycle_lengths = {}

# Iterate over all the nodes in the graph
for node in graph:

# If we haven't seen this node before, it can't be part of a cycle
# that we've already found, so we'll run our cycle detection algorithm
# on it.
if node not in cycle_lengths:
cycle_lengths[node] = find_cycle_length(graph, node)

# Find the maximum cycle length
max_length = 0
for node, length in cycle_lengths.items():
max_length = max(max_length, length)

return max_length

def find_cycle_length(graph, start):
"""
Given a graph and a starting node, find the length of the longest cycle
that includes the starting node.
"""

# Keep track of the nodes we've visited and the length of the current path
visited = set()
path_length = 0

# Perform a depth-first search from the starting node
stack = [start]
while stack:
node = stack.pop()

# If we've visited the node before, we've found a cycle!
if node in visited:
return path_length - visited[node]

# Mark the node as visited and add it to the path
visited[node] = path_length
path_length += 1

# Add all the node's neighbors to the stack
for neighbor in graph[node]:
stack.append(neighbor)

# If we get here, then we didn't find a cycle
return 0```
`There are many possible solutions to this problem. One approach would be to use a depth-first search algorithm to find the longest path through the graph. Another approach would be to use a breadth-first search algorithm to find the shortest path between two nodes.`
```There are many possible solutions to this problem. One approach is to use a depth-first search algorithm to find the longest path through the graph. The code for this solution is provided below.

void findLongestPath(int cur, int prev, int length, int &maxLength, vector> &graph) { if (length > maxLength) { maxLength = length; } for (int i = 0; i < graph[cur].size(); i++) { if (graph[cur][i] != prev) { findLongestPath(graph[cur][i], cur, length + 1, maxLength, graph); } } } int longestCycle(vector> &graph) { int maxLength = 0; for (int i = 0; i < graph.size(); i++) { findLongestPath(i, -1, 0, maxLength, graph); } return maxLength; }```
```using System;
using System.Collections.Generic;

public class Solution {

// We can use DFS to find the longest cycle in a graph

public int LongestCycle(int[][] edges) {

// Create a graph using adjacency list

Dictionary> graph = new Dictionary>();

// Add all the edges to the graph

foreach (int[] edge in edges) {

if (!graph.ContainsKey(edge[0])) {

}

if (!graph.ContainsKey(edge[1])) {

}

}

// Variable to store the longest cycle

int longestCycle = 0;

// DFS function

DFS(graph, new HashSet(), -1, 0, ref longestCycle);

return longestCycle;

}

public void DFS(Dictionary> graph, HashSet visited, int parent, int curr, ref int longestCycle) {

// Mark the current node as visited

// Iterate over all the neighbors of the current node

foreach (int neighbor in graph[curr]) {

// If the neighbor has not been visited

if (!visited.Contains(neighbor)) {

// Recursively call the DFS function

DFS(graph, visited, curr, neighbor, ref longestCycle);

}

// If the neighbor has been visited and it is not the parent

else if (neighbor != parent) {

// Update the longest cycle

longestCycle = Math.Max(longestCycle, visited.Count);

}

}

// Remove the current node from the visited set

visited.Remove(curr);

}

}```

Scroll to Top

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]