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

        visited[v] = True

        print(self.vertex_data[v], end=' ')

​

        for i in range(self.size):

            if self.adj_matrix[v][i] == 1 and not visited[i]:

                self.dfs_util(i, visited)

​

    def dfs(self, start_vertex_data):

        visited = [False] * self.size

​

        start_vertex = self.vertex_data.index(start_vertex_data)

        self.dfs_util(start_vertex, visited)

    def bfs(self, start_vertex_data):

        queue = [self.vertex_data.index(start_vertex_data)]

        visited = [False] * self.size

        visited[queue[0]] = True

        while queue:

            current_vertex = queue.pop(0)

            print(self.vertex_data[current_vertex], end=' ')

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

​

typedef struct {

    int **adj_matrix;

    char *vertex_data;

    int size;

} Graph;

​

Graph* create_graph(int size) {

    Graph *g = malloc(sizeof(Graph));

    g->size = size;

​

    g->adj_matrix = malloc(size * sizeof(int *));

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

        g->adj_matrix[i] = calloc(size, sizeof(int));

    }

​

    g->vertex_data = malloc(size * sizeof(char));

    return g;

}

​

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

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

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

        // g->adj_matrix[v][u] = 1;

    }

}

​

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

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

        g->vertex_data[vertex] = data;

    }

}

​

void print_graph(Graph *g) {

    printf("Adjacency Matrix:\n");

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

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

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

        }

        printf("\n");

    }

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

public class Main {

    static class Graph {

        private int[][] adjMatrix;

        private String[] vertexData;

        private int size;

​

        public Graph(int size) {

            this.size = size;

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

            this.vertexData = new String[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, String data) {

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

                vertexData[vertex] = data;

            }

        }

​

        public void printGraph() {

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

            for (int[] row : adjMatrix) {

                for (int val : row) {

                    System.out.print(val + " ");

                }

                System.out.println();

            }

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

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

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

            }

        }

​

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

            visited[v] = true;

            System.out.print(vertexData[v] + " ");

​

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

                if (adjMatrix[v][i] == 1 && !visited[i]) {