Print negative weight cycle in a Directed Graph

// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;

class GFG {

    // Structure to represent a weighted
    // edge in graph
    class Edge {
        public int src, dest, weight;
    }
    // Structure to represent a directed
    // and weighted graph
    class Graph {

        // V. Number of vertices, E. Number of edges
        public int V, E;

        // graph is represented as an array of edges.
        public Edge[] edge;
    }

    // Creates a new graph with V vertices
    // and E edges
    static Graph createGraph(int V, int E)
    {
        Graph graph = new Graph();
        graph.V = V;
        graph.E = E;
        graph.edge = new Edge[graph.E];

        for (int i = 0; i < graph.E; i++) {
            graph.edge[i] = new Edge();
        }

        return graph;
    }

    // Function runs Bellman-Ford algorithm
    // and prints negative cycle(if present)
    static void NegCycleBellmanFord(Graph graph, int src)
    {
        int V = graph.V;
        int E = graph.E;
        int[] dist = new int[V];
        int[] parent = new int[V];

        // Initialize distances from src
        // to all other vertices as INFINITE
        // and all parent as -1
        for (int i = 0; i < V; i++) {

            dist[i] = 1000000;
            parent[i] = -1;
        }
        dist[src] = 0;

        // Relax all edges |V| - 1 times.
        for (int i = 1; i <= V - 1; i++) {
            for (int j = 0; j < E; j++) {

                int u = graph.edge[j].src;
                int v = graph.edge[j].dest;
                int weight = graph.edge[j].weight;

                if (dist[u] != 1000000
                    && dist[u] + weight < dist[v]) {

                    dist[v] = dist[u] + weight;
                    parent[v] = u;
                }
            }
        }

        // Check for negative-weight cycles
        int C = -1;
        for (int i = 0; i < E; i++) {

            int u = graph.edge[i].src;
            int v = graph.edge[i].dest;
            int weight = graph.edge[i].weight;

            if (dist[u] != 1000000
                && dist[u] + weight < dist[v]) {

                // Store one of the vertex of
                // the negative weight cycle
                C = v;
                break;
            }
        }

        if (C != -1) {

            for (int i = 0; i < V; i++)
                C = parent[C];

            // To store the cycle vertex
            ArrayList cycle = new ArrayList();
            for (int v = C;; v = parent[v]) {

                cycle.Add(v);
                if (v == C && cycle.Count > 1)
                    break;
            }

            // Reverse cycle[]
            cycle.Reverse();

            // Printing the negative cycle
            foreach(int v in cycle) Console.Write(v + " ");
            Console.WriteLine();
        }
        else
            Console.WriteLine(-1);
    }

    // Driver Code
    public static void Main(string[] args)
    {

        // Number of vertices in graph
        int V = 5;

        // Number of edges in graph
        int E = 5;

        Graph graph = createGraph(V, E);

        // Given Graph
        graph.edge[0].src = 0;
        graph.edge[0].dest = 1;
        graph.edge[0].weight = 1;

        graph.edge[1].src = 1;
        graph.edge[1].dest = 2;
        graph.edge[1].weight = 2;

        graph.edge[2].src = 2;
        graph.edge[2].dest = 3;
        graph.edge[2].weight = 3;

        graph.edge[3].src = 3;
        graph.edge[3].dest = 4;
        graph.edge[3].weight = -3;

        graph.edge[4].src = 4;
        graph.edge[4].dest = 1;
        graph.edge[4].weight = -3;

        // Function Call
        NegCycleBellmanFord(graph, 0);
    }
}

// This code is contributed by rutvik_56