# 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:

- Initialize a variable max_cycle_length to 0.
- For each node in the graph, perform a DFS starting from that node and calculate the maximum length of the cycle found.
- If the length of the cycle found is greater than max_cycle_length, update max_cycle_length with the new value.
- 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:

- 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.
- For each unvisited node, perform a DFS starting from that node.
- In the DFS function, mark the current node as visited and iterate over all its neighbors.
- If a neighbor is not visited, set its parent to the current node and recursively call the DFS function on it.
- 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.
- 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])) { graph.Add(edge[0], new List ()); } if (!graph.ContainsKey(edge[1])) { graph.Add(edge[1], new List ()); } graph[edge[0]].Add(edge[1]); graph[edge[1]].Add(edge[0]); } // 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 visited.Add(curr); // 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); } }