Shortest cycle

 #include <stdio.h>
    #include <stdlib.h>
    #include<string.h>
    #define INT_MAX 99999
    #define INT_MIN -99999

    //ADJACENCY LIST
    struct node {
    int vertex;
    struct node* next;
    };
    struct node* createNode(int);

    struct Graph {
    int numVertices;
    struct node** adjLists;
    };

    // Create a node
    struct node* createNode(int v) {
    struct node* newNode = malloc(sizeof(struct node));
    newNode->vertex = v;
    newNode->next = NULL;
    return newNode;
    }

    // Create a graph
    struct Graph* createAGraph(int vertices) {
    struct Graph* graph = malloc(sizeof(struct Graph));
    graph->numVertices = vertices;

    graph->adjLists = malloc(vertices * sizeof(struct node*));

    int i;
    for (i = 0; i < vertices; i++)
        graph->adjLists[i] = NULL;

    return graph;
    }

    // Add edge
    void addEdge(struct Graph* graph, int s, int d) {
    // Add edge from s to d
    struct node* newNode = createNode(d);
    newNode->next = graph->adjLists[s];
    graph->adjLists[s] = newNode;

    // Add edge from d to s
    newNode = createNode(s);
    newNode->next = graph->adjLists[d];
    graph->adjLists[d] = newNode;
    }

    // Print the graph
    void printGraph(struct Graph* graph) {
    int v;
    for (v = 0; v < graph->numVertices; v++)
    {
        struct node* temp = graph->adjLists[v];
        //printf("\n Vertex %d\n: ", v);
        while (temp) {
        printf("%d ", temp->vertex);
        temp = temp->next;
        }
        printf("\n");
    }
    }

    //QUEUE
    struct Queue
    {
        int front, rear, size;
        unsigned capacity;
        int* array;
    };

    // function to create a queue of given capacity.
    // It initializes size of queue as 0
    struct Queue* createQueue(unsigned capacity)
    {
        struct Queue* queue = (struct Queue*) malloc(sizeof(struct Queue));
        queue->capacity = capacity;
        queue->front = queue->size = 0;
        queue->rear = capacity - 1;  // This is important, see the enqueue
        queue->array = (int*) malloc(queue->capacity * sizeof(int));
        return queue;
    }

    // Queue is full when size becomes equal to the capacity
    int isFull(struct Queue* queue)
    {  return (queue->size == queue->capacity);  }

    // Queue is empty when size is 0
    int isEmpty(struct Queue* queue)
    {  return (queue->size == 0); }

    // Function to add an item to the queue.
    // It changes rear and size
    void enqueue(struct Queue* queue, int item)
    {
        if (isFull(queue))
            return;
        queue->rear = (queue->rear + 1)%queue->capacity;
        queue->array[queue->rear] = item;
        queue->size = queue->size + 1;
    }

    // Function to remove an item from queue.
    // It changes front and size
    int dequeue(struct Queue* queue)
    {
        if (isEmpty(queue))
            return INT_MIN;
        int item = queue->array[queue->front];
        queue->front = (queue->front + 1)%queue->capacity;
        queue->size = queue->size - 1;
        return item;
    }

    // Function to get front of queue
    int front(struct Queue* queue)
    {
        if (isEmpty(queue))
            return INT_MIN;
        return queue->array[queue->front];
    }

    int min(int a,int b)
    {
    return (a<b)?a:b;
    }

    int shortest_cycle(struct Graph* graph,int n) 
    { 
        // To store length of the shortest cycle 
        int ans = INT_MAX; 

        // For all vertices 
        for (int i = 0; i < n; i++) { 

            // Make distance maximum 
            int dist[n];
            for(int i=0;i<n;i++)
            dist[i]=INT_MAX;

            // Take a imaginary parent 
            int par[n] ; 
            for(int i=0;i<n;i++)
            par[i]= -1;

            // Distance of source to source is 0 
            dist[i] = 0; 
            struct Queue* q = createQueue(1000);

            // Push the source element 
            enqueue(q,i);

            // Continue until queue is not empty 
            while (!isEmpty(q)) { 

                // Take the first element 
                int x = front(q); 
                dequeue(q); 


                // Traverse for all it's childs 
                struct node* temp = graph->adjLists[x];
                while(temp) { 

                    // If it is not visited yet 
                    if (dist[temp->vertex] == INT_MAX) { 

                        // Increase distance by 1 
                        dist[temp->vertex] = 1 + dist[x]; 

                        // Change parent 
                        par[temp->vertex] = x; 

                        // Push into the queue 
                        enqueue(q,temp->vertex); 
            } 

                    // If it is already visited 
                    else if (par[x] != temp->vertex) 
                        ans = min(ans, dist[x] + dist[temp->vertex] + 1); 

                    temp = temp->next;
                } 
            } 
        } 

        // If graph contains no cycle 
        if (ans == INT_MAX) 
            return -1; 

        // If graph contains cycle 
        else
            return ans; 
    } 

    int main() 
    { 
    int t;
    scanf("%d",&t);
    while(t--)
    {

        int n ,e;
        scanf("%d %d",&n,&e);
        struct Graph* graph = createAGraph(n);

        while(e--)
        {

    int u,v;
    scanf("%d %d",&u,&v);
        addEdge(graph, u,v); 
        }
        printf("%d\n",shortest_cycle(graph,n));

    }

        return 0; 
    }