Parenthesis Theorem

import java.util.*;

public class Main {
    
    // For recording time
    static int tim = 0;
    // For creating Graph
    static ArrayList<Integer>[] G;
    // For calculating Discovery time and finishing time of nodes
    static int[] disc, fin;
    // For finding Parent of node
    static int[] Par;
    // For storing color of node
    static char[] Color;
    
    // Recursive function for DFS to update the
    static void DFS_Visit(int v) {
        // Make the current nodes as visited
        Color[v] = 'G';
        // Increment the time
        tim += 1;
        // Assign the Discovery node of node v
        disc[v] = tim;
        // Traverse the adjacency list of vertex v
        for(int i = 0; i < G[v].size(); i++) {
            int it = G[v].get(i);
            // If the nodes is not visited, then mark the parent of the current node and call DFS_Visit for the current node
            if(Color[it] == 'W') {
                Par[it] = v;
                DFS_Visit(it);
            }
        }
        Color[v] = 'B';
        tim = tim + 1;
        fin[v] = tim;
    }
    
    static void DFS(ArrayList<Integer>[] graph) {
        // Initialise Par, disc, fin and Color vector to size of graph
        Par = new int[graph.length];
        disc = new int[graph.length];
        fin = new int[graph.length];
        Color = new char[graph.length];
        // Initialise the Par[], Color[], disc[], fin[]
        for (int i = 1; i < graph.length; i++) {
            Color[i] = 'W';
            Par[i] = 0;
            disc[i] = 0;
            fin[i] = 0;
        }
        // For every vertex if nodes is not visited then call DFS_Visit to update the discovery and finishing time of the node
        for (int i = 1; i < graph.length; i++) {
            // If color is 'W', then node is not visited
            if (Color[i] == 'W') {
                DFS_Visit(i);
            }
        }
    }
    
    // Function to check whether time intervals of x and y overlaps or not
    static boolean checkOverlap(int x, int y) {
        // Find the time intervals
        int x1 = disc[x], y1 = fin[x];
        int x2 = disc[y], y2 = fin[y];
        // Complete overlaps
        if (x2 > x1 && y1 > y2) {
            return true;
        }
        else {
            return false;
        }
    }
    
    // Function to check which Edges (x, y) belongs
    static String checkEdge(int x, int y) {
        // For Tree Edge If x is parent of y, then it is Tree Edge
        if (Par[y] == x) {
            return "Tree Edge";
        }
        // For Forward Edge
        else if (checkOverlap(x, y)) {
            return "Forward Edge";
        }
        // For Backward Edge
        else if (checkOverlap(y, x)) {
            return "Backward Edge";
        }
        else {
            return "Cross Edge";
        }
    }
    
    // Function call to find the Tree Edge, Back Edge, Forward Edge, and Cross Edge
    static void solve(int[][] arr, int N, int M) {
        // Create graph of

        G = new ArrayList[N + 1];
        for (int i = 0; i < N + 1; i++) {
            G[i] = new ArrayList<Integer>();
        }
        // Traverse each edges
        for (int i = 0; i < M; i++) {
            int x = arr[i][0];
            int y = arr[i][1];
            // Make Directed graph
            G[x].add(y);   
        }
        // DFS call to calculate discovery and finishing time for each node
        DFS(G);
        // Condition for Tree Edge, Forward Edges, Backward Edge and Cross Edge
        for (int i = 0; i < M; i++) {
            int x = arr[i][0];
            int y = arr[i][1];
            // Function call to check Edges
            System.out.println("(" + x + "," + y + ")->" + checkEdge(x, y));
        }
    }
    
    public static void main(String[] args) {
        // Number of Nodes
        int N = 5;
        // Number of Edges
        int M = 7;
        // Edges for the graph
        int[][] arr= {{1, 2} , {1, 3 }, {3, 4} , {1, 4 }, {2, 5} , {5, 1 }, {3, 1}};
        // Function Call
        solve(arr, N, M);
    }
}