class Graph:

    def __init__(self, size):

        self.adj_matrix = [[0] * size for _ in range(size)]

        self.size = size

        self.vertex_data = [''] * size  

​

    def add_edge(self, u, v):

        if 0 <= u < self.size and 0 <= v < self.size:

            self.adj_matrix[u][v] = 1

            self.adj_matrix[v][u] = 1

​

    def add_vertex_data(self, vertex, data):

        if 0 <= vertex < self.size:

            self.vertex_data[vertex] = data

​

    def print_graph(self):

        print("Adjacency Matrix:")

        for row in self.adj_matrix:

            print(' '.join(map(str, row)))

        print("\nVertex Data:")

        for vertex, data in enumerate(self.vertex_data):

            print(f"Vertex {vertex}: {data}")

    def dfs_util(self, v, visited, parent):

        visited[v] = True

​

        for i in range(self.size):

            if self.adj_matrix[v][i] == 1:

                if not visited[i]:

                    if self.dfs_util(i, visited, v):

                        return True

                elif parent != i:

                    return True

        return False

​

    def is_cyclic(self):

        visited = [False] * self.size

        for i in range(self.size):

            if not visited[i]:

                if self.dfs_util(i, visited, -1):

                    return True

        return False

​

g = Graph(7)

​

#include <stdio.h>

#include <stdbool.h>

​

#define SIZE 7

​

typedef struct {

    int adjMatrix[SIZE][SIZE];

    char vertexData[SIZE];

} Graph;

​

void initGraph(Graph *g) {

    for (int i = 0; i < SIZE; i++) {

        for (int j = 0; j < SIZE; j++) {

            g->adjMatrix[i][j] = 0;

        }

        g->vertexData[i] = '\0';

    }

}

​

void addEdge(Graph *g, int u, int v) {

    if (u >= 0 && u < SIZE && v >= 0 && v < SIZE) {

        g->adjMatrix[u][v] = 1;

        g->adjMatrix[v][u] = 1;

    }

}

​

void addVertexData(Graph *g, int vertex, char data) {

    if (vertex >= 0 && vertex < SIZE) {

        g->vertexData[vertex] = data;

    }

}

​

void printGraph(Graph *g) {

    printf("Adjacency Matrix:\n");

    for (int i = 0; i < SIZE; i++) {

        for (int j = 0; j < SIZE; j++) {

            printf("%d ", g->adjMatrix[i][j]);

        }

        printf("\n");

    }

​

    printf("\nVertex Data:\n");

    for (int i = 0; i < SIZE; i++) {

        printf("Vertex %d: %c\n", i, g->vertexData[i]);

    }

public class Main {

    static class Graph {

        private int[][] adjMatrix;

        private char[] vertexData;

        private int size;

​

        public Graph(int size) {

            this.size = size;

            this.adjMatrix = new int[size][size];

            this.vertexData = new char[size];

        }

​

        public void addEdge(int u, int v) {

            if (u >= 0 && u < size && v >= 0 && v < size) {

                adjMatrix[u][v] = 1;

                adjMatrix[v][u] = 1;

            }

        }

​

        public void addVertexData(int vertex, char data) {

            if (vertex >= 0 && vertex < size) {

                vertexData[vertex] = data;

            }

        }

​

        public void printGraph() {

            System.out.println("Adjacency Matrix:");

            for (int i = 0; i < size; i++) {

                for (int j = 0; j < size; j++) {

                    System.out.print(adjMatrix[i][j] + " ");

                }

                System.out.println();

            }

            System.out.println("\nVertex Data:");

            for (int i = 0; i < size; i++) {

                System.out.println("Vertex " + i + ": " + vertexData[i]);

            }

        }

​

        private boolean dfsUtil(int v, boolean[] visited, int parent) {

            visited[v] = true;

​

            for (int i = 0; i < size; i++) {

                if (adjMatrix[v][i] == 1) {

                    if (!visited[i]) {