From 0f4966b5a97ccd77deb8b4f57978a0bde62694b8 Mon Sep 17 00:00:00 2001 From: DavidJipescu <168351040+DavidJipescu@users.noreply.github.com> Date: Sun, 28 Apr 2024 19:06:55 +0300 Subject: [PATCH 1/3] Create Exercitiul_1 --- Exercitiul_1 | 162 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 Exercitiul_1 diff --git a/Exercitiul_1 b/Exercitiul_1 new file mode 100644 index 0000000..31f22fd --- /dev/null +++ b/Exercitiul_1 @@ -0,0 +1,162 @@ +/*Determinati daca exista sau nu drum intre doua restaurante dintr-o retea de tip graf*/ + +#include +#include + +typedef struct Node +{ + int data; + struct Node *next; +} NODE; +// pentru simplitate, folosim int uri pt a numi restaurantele/locatiile +// ex: 1 - restaurantul 1 si tot asa + +typedef struct Graph +{ + int number_of_restaurants; + int *visited_restaurants; + struct Node **adjacency_list; +} GPH; + +typedef struct Stack +{ + int t; + int scap; + int *stack_array; +} STK; + +NODE *create_node(int value) +{ + NODE *node = malloc(sizeof(NODE)); + node->data = value; + node->next = NULL; + return node; +} + +void add_edge(GPH *graph, int source, int destination) +{ + NODE *node = create_node(destination); + node->next = graph->adjacency_list[source]; + graph->adjacency_list[source] = node; + + node = create_node(source); + node->next = graph->adjacency_list[destination]; + graph->adjacency_list[destination] = node; +} + +GPH *create_graph(int node_number) +{ + GPH *graph = malloc(sizeof(GPH)); + graph->number_of_restaurants = node_number; + graph->adjacency_list = malloc(node_number * sizeof(NODE *)); // CORECTAT + graph->visited_restaurants = malloc(node_number * sizeof(int)); + + for (int i = 0; i < node_number; i++) + { + graph->adjacency_list[i] = NULL; + graph->visited_restaurants[i] = 0; + } + return graph; +} + +STK *create_stack(int scap) +{ + STK *s = malloc(sizeof(STK)); + s->stack_array = malloc(scap * sizeof(int)); + s->t = -1; + s->scap = scap; + return s; +} + +void push(int pushed_value, STK *stack) +{ + stack->t = stack->t + 1; + stack->stack_array[stack->t] = pushed_value; +} + +void visit_restaurants_DFS(GPH *graph, STK *stack, int current_restaurant) +{ + NODE *adj_list = graph->adjacency_list[current_restaurant]; + NODE *aux = adj_list; + + graph->visited_restaurants[current_restaurant] = 1; + printf("%d -> ", current_restaurant); + push(current_restaurant, stack); + while (aux != NULL) + { + int near_restaurant = aux->data; + if (graph->visited_restaurants[near_restaurant] == 0) + { + visit_restaurants_DFS(graph, stack, near_restaurant); + } + aux = aux->next; + } +} + +void insert_edges(GPH *graph, int edge_number, int node_number) +{ + int source, destination, i; + printf("adauga %d muchii (de la 1 la %d)\n", + edge_number, node_number); + for (i = 0; i < edge_number; i++) + { + scanf("%d%d", &source, &destination); + add_edge(graph, source, destination); + } +} + +void wipe(GPH *graph, int node_number) +{ + for (int i = 0; i < node_number; i++) + { + graph->visited_restaurants[i] = 0; + } +} + +void could_it_be_visited(GPH *graph, int node_number) // 0 sau 1 - daca poate fi sau nu ajuns PENTRU GRAPH->VISITED_RESTAURANTS + AFISARI ADECVATE (completare) +{ + for (int i = 0; i < node_number; i++) + { + STK *stack = create_stack(node_number); + wipe(graph, node_number); + printf("\n"); + visit_restaurants_DFS(graph, stack, i); + for (int j = 0; j < node_number; j++) + { + if (i != j) + { + if (graph->visited_restaurants[j]) + { + printf("\nExista drum intre restaurantele %4d si %d", i, j); + } + else + { + printf("\nNU exista drum intre restaurantele %d si %d", i, j); + } + } + } + free(stack->stack_array); + free(stack); + printf("\n"); + } +} + +int main() +{ + int node_number; + int edge_number; + + printf("cate noduri are graful? "); + scanf("%d", &node_number); + + printf("cate muchii are graful? "); + scanf("%d", &edge_number); + + GPH *graph = create_graph(node_number); + + insert_edges(graph, edge_number, node_number); + + could_it_be_visited(graph, node_number); +} +//Modificari mai importante aduse functiei canbe() (actuala could_it_be_visited()) +//A se citi detaliile din fisierul pdf! From 4183eabc23ce32b8d9f73a6c99097b04ad4c5ac6 Mon Sep 17 00:00:00 2001 From: DavidJipescu <168351040+DavidJipescu@users.noreply.github.com> Date: Sun, 28 Apr 2024 19:07:39 +0300 Subject: [PATCH 2/3] Rename Exercitiul_1 to Exercitiul_1.c --- Exercitiul_1 => Exercitiul_1.c | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Exercitiul_1 => Exercitiul_1.c (100%) diff --git a/Exercitiul_1 b/Exercitiul_1.c similarity index 100% rename from Exercitiul_1 rename to Exercitiul_1.c From b418316073db4a085ecf1743044152567b663422 Mon Sep 17 00:00:00 2001 From: DavidJipescu <168351040+DavidJipescu@users.noreply.github.com> Date: Sun, 28 Apr 2024 19:14:15 +0300 Subject: [PATCH 3/3] Create Exercitiul_2.c --- Exercitiul_2.c | 205 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 Exercitiul_2.c diff --git a/Exercitiul_2.c b/Exercitiul_2.c new file mode 100644 index 0000000..6451929 --- /dev/null +++ b/Exercitiul_2.c @@ -0,0 +1,205 @@ +#include +#include + + +typedef struct Node { + int data; + struct Node *next; +} NODE; + +typedef struct Graph { + int vertices; + int *visited; + struct Node **adjacency_lists; +} GPH; +/// utils + +NODE *create_node(int v) { + NODE *new_node = malloc(sizeof(NODE)); + new_node->data = v; + new_node->next = NULL; + return new_node; +} + +GPH *create_graph(int vertices) +{ + int i; + GPH *graph = malloc(sizeof(GPH)); + graph->vertices = vertices; + graph->adjacency_lists = malloc(vertices * sizeof(NODE *)); + + graph->visited = malloc(sizeof(int) * vertices); + for (int i = 0; i < vertices; i++) + { + graph->adjacency_lists[i] = NULL; + graph->visited[i] = 0; + } + return graph; +} + +void add_edge(GPH *graph, int src, int dest) +{ + NODE *new_node = create_node(dest); + + new_node->next = graph->adjacency_lists[src]; + graph->adjacency_lists[src] = new_node; + + new_node = create_node(src); + + new_node->next = graph->adjacency_lists[dest]; + graph->adjacency_lists[dest] = new_node; +} + +int *insedg(int nr_of_vertices, int nr_of_edges, GPH *graph) +{ + int src, dest, i; + printf("adauga %d muchii (de la 1 la %d)\n", nr_of_edges, nr_of_vertices); + for (i = 0; i < nr_of_edges; i++) + { + scanf("%d%d", &src, *&dest);add_edge(graph, src, dest); + } +} + +/// bfs utils +int is_empty(NODE *queue) +{ + return queue == NULL; +} + +void enqueue(NODE *queue, int data)//trei stelute +{ + NODE *new_node = create_node(data); + + if (is_empty(queue))//*queue + queue = new_node; + else + { + NODE *temp = queue;//steluta + + while (temp->next) + { + temp = temp->next; + } + temp->next = new_node; + } +} + +int dequeue(NODE **queue) +{ + int data = (*queue)->data; + NODE *temp = *queue;*queue = (*queue)->next; + + return data; +} + +void print_graph(GPH *graph) +{ + int i; + for (i = 0; i < graph->vertices; i += 1) ///(i<<2) +=1) + { + NODE *temp = graph->adjacency_lists[i]; + + while (temp) { + printf("%d ", temp->data); + temp = (temp->next); + } + printf("\n"); + } +} + +void print_queue(NODE *queue) +{ + while (queue != NULL) + { + printf("%d ", queue->data); + queue = (queue->next)->next; + } +} + +void wipe_visited_list(GPH *graph, int nr_of_vertices) +{ + for (int i = 0; i < nr_of_vertices; i++) + { + graph->visited[i] = 0; + } +} +// parcurgeri +void DFS(GPH *graph, int vertex_nr) +{ + NODE *adj_list = graph->adjacency_lists[vertex_nr]; + NODE *temp = adj_list; + + graph->visited[vertex_nr] = 1; + printf("%d->", vertex_nr); + + while (temp != NULL) + { + int connected_vertex = temp->data; + + if (graph->visited[connected_vertex] == 0) + { + DFS(graph, connected_vertex); + } + temp = temp->next; + } +} + +void BFS(GPH *graph, int start) +{ + NODE *queue = NULL; + + graph->visited[start] = 1; + enqueue(queue, start); + + while (!is_empty(queue)) + { + int current = dequeue(&queue); + printf("%d ", current); + + NODE *temp = graph->adjacency_lists[current]; + + while (temp) + { + int adj_vertex = temp->data; + + if (graph->visited[adj_vertex] == 0) + { + graph->visited[adj_vertex] = 1; + enqueue(&*queue, adj_vertex); + } + temp = temp->next; + } + } +} + +int main() +{ + int nr_of_vertices; + int nr_of_edges; + int src, dest; + + int i; + int starting_vertex; + int *adj_matrix; + + printf("cate noduri are graful?"); + scanf("%d", &(nr_of_vertices)); + printf("cate muchii are graful?"); + scanf("%d", &(nr_of_edges)); + + GPH *graph = create_graph(nr_of_vertices); + insedg(nr_of_vertices, nr_of_edges, graph); + printf("de unde plecam in DFS?"); + scanf("%d", &(starting_vertex)); // =))) + printf("parcurgere cu DFS:"); + DFS(graph, starting_vertex); + wipe_visited_list(graph, nr_of_vertices); + printf("\n"); + printf("de unde plecam in BFS?"); + scanf("%d", &starting_vertex); + printf("parcurgere cu BFS:"); + BFS(graph, starting_vertex); + + + return 0; +}