graph folder

dsa2_course/graphs/intro.c

@@ -0,0 +1,110 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <iso646.h>
+
+// // Implementando um grafo com matriz de adjacência
+// typedef struct grafo {
+//     int **adj;
+//     int v;
+// } grafo;
+
+// // criando um grafo
+// grafo *cria_grafo(int n) {
+//     grafo *g = malloc(sizeof(grafo));
+//     g->v = n;
+//     g->adj = malloc(sizeof(int) * n);
+
+//     for(int i = 0; i < n; ++i) {
+//         g->adj[i] = malloc(sizeof(int) * n);
+//         for(int j = 0; j < n; ++j)
+//             g->adj[i][j] = 0;
+//     }
+
+//     return g;
+// }
+
+// // destruindo um grafo
+// void destroi_grafo(grafo *g) {
+//     for(int i = 0; i < g->v; ++i)
+//         free(g->adj[i]);
+//     free(g->adj);
+//     free(g);
+// }
+
+// // grau do vértice
+// int grau(grafo *g, int v) {
+//     int grau = 0;
+//     for(int u = 0; u < g->v; ++u)
+//         if(g->adj[v][u])
+//             ++grau;
+//     return grau;
+// }
+
+// // imprimindo recomendações
+// void imprime_recomendacao(grafo *g, int v) {
+//     for(int u = 0; u < g->v; ++u) {
+//         if(g->adj[v][u])
+//             for(int w = 0; w < g->v; ++w)
+//                 if(g->adj[u][w] and w != v and (not g->adj[v][w]))
+//                     printf("%d ", w);
+//     }
+
+//     printf("\n");
+// }
+
+// Implementando grafos com lista de adjâcência
+typedef struct no {
+    int v;
+    struct no *next;
+} no;
+
+typedef struct grafo {
+    no **adj;
+    int v;
+} grafo;
+
+
+// criando um grafo / inicializando um grafo
+grafo *cria_grafo(int n) {
+    grafo *g = malloc(sizeof(grafo));
+    g->v = n;
+    g->adj = malloc(sizeof(no) * n);
+
+    for(int i = 0; i <n; ++i) 
+        g->adj[i] = NULL;
+
+    return g;
+}
+
+// inserir no início da lista de um no adjâscente
+no *insere_list(no *list, int v) {
+    no *novo = malloc(sizeof(no));
+    novo->v = v;
+    novo->next = list;
+    return novo;
+}
+
+// inserindo uma aresta em um grafo não direcionado
+void insere_aresta(grafo *g, int v, int u) {
+    g->adj[v] = insere_list(g->adj[v],u);
+    g->adj[u] = insere_list(g->adj[u],v);
+} 
+
+// imprimindo um grafo
+void imprime_grafo(grafo *g) {
+    for(int v = 0; v < g->v; ++v) {
+        no *adj = g->adj[v];
+        printf("%d -> ", v);
+        while(adj) {
+            printf("%d ", adj->v);
+            adj = adj->next;
+        }
+        printf("\n");
+    }
+}
+
+
+int main(void) {
+    return 0;
+}

dsa2_course/graphs/introGraph_matrix.c

@@ -0,0 +1,82 @@
+// Introdução à grafos, principais funções e implementação com matrix de adjacência
+#include <stdio.h>
+#include <stdlib.h>
+#include <iso646.h>
+
+// Definindo algumas estruturas importantes para auxiliar na criação do Grafo
+typedef struct {int v; int w;} Edge;
+
+// Função para criar um par de arestas
+Edge *edge(int x, int y) {
+
+    Edge *ed = malloc(sizeof(Edge));
+    ed->v = x;
+    ed->w = y;
+
+    return ed;
+}
+
+typedef struct Graph{
+    int v, e;
+    int **adj;
+
+} graph;
+
+// Criando um grafo e alocando uma matrix de forma dinâmica
+graph *GraphInit(int v) {
+
+    graph *g = malloc(sizeof(graph));
+    g->v = v;
+    g->e = 0;
+    g->adj = malloc(sizeof(int*) *v);
+    for(int i = 0; i < v; ++i) {
+        g->adj[i] = malloc(sizeof(int)*v);
+        g->adj[i] = 0;
+    }
+
+    return g;
+}
+
+
+// Implementando uma função para adicioanr arestas em um grafo já inicializado
+void GraphInsertEd(graph *g, Edge e, int dir) {
+
+    // Se não for um digrafo, então é bidirecional
+    if((not dir) and (not g->adj[e.v][e.w])) {    
+        g->adj[e.v][e.w] = 1;
+        g->adj[e.w][e.v] = 1;
+        g->e++;
+    } else if(dir and (not g->adj[e.v][e.w])) {
+        g->adj[e.v][e.w] = 1;
+        g->e++;
+    }
+
+}
+
+// Implementando uma função para remover uma aresta do grafo
+void GraphRemoveEd(graph *g, Edge e, int dir) {
+
+    // Se não for um digrafo, então é bidirecional
+    if((not dir) and (g->adj[e.v][e.w])) {
+        g->adj[e.v][e.w] = 0;
+        g->adj[e.v][e.w] = 0;
+        g->e--;
+    } else if(dir and (g->adj[e.v][e.w])) {
+        g->adj[e.v][e.w] = 0;
+        g->e--;
+    }
+
+}
+
+// Implemetando uma função para retornar um vetor de arestas presentes no grafo
+int *GraphEdges(Edge e[], graph *g) {
+
+    int idx = 0;
+    for(int v = 0; v < g->v; ++v)
+        for(int w = v+1; w < g->v; ++w)
+            if(g->adj[v][w]) {
+                e[idx++] = *edge(v,w);
+            }
+
+    return idx;
+}

dsa2_course/graphs/problemsets/BFSofGraph.cpp

@@ -0,0 +1,21 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> bfsOfGraph(int V, vector<int> adj[]) {
+    vector<int> vis(V,0), ans;
+    vis[0] = 1;
+    queue<int> q;
+    q.push(0);
+
+    while(not q.empty()) {
+        int vertice = q.front();
+        q.pop();
+
+        ans.emplace_back(vertice);
+        for(auto x : adj[vertice]) if (not vis[x]) {
+            vis[x] = 1;
+            q.push(x);
+        }
+    }
+    return ans;
+}

dsa2_course/graphs/problemsets/DFSofGraph.cpp

@@ -0,0 +1,18 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void dfs(int v, vector<int> adj[], vector<int>& vis, vector<int>& ans) {
+    vis[v] = 1;
+    ans.push_back(v);
+    for (int u : adj[v]) {
+        if (!vis[u]) {
+            dfs(u, adj, vis, ans);
+        }
+    }
+}
+
+vector<int> dfsOfGraph(int V, vector<int> adj[]) {
+    vector<int> vis(V, 0), ans;
+    dfs(0, adj, vis, ans);
+    return ans;
+}

dsa2_course/graphs/problemsets/componentesConectados.c

@@ -0,0 +1,126 @@
+/*
+Problema: Componentes Conectados em um Grafo
+
+Descrição:
+
+Você deve implementar um programa em C que encontre e liste todos os componentes conectados de um grafo não direcionado.
+
+Entrada:
+
+    O número de vértices V no grafo.
+    O número de arestas E no grafo.
+    As próximas E linhas contêm dois inteiros u e v representando uma aresta entre o vértice u e o vértice v.
+
+Saída:
+
+    O número de componentes conectados no grafo.
+    Para cada componente conectado, liste os vértices pertencentes a esse componente.
+
+Exemplo de Entrada:
+
+6
+5
+0 1
+0 2
+1 2
+3 4
+4 5
+
+Exemplo de Saída:
+
+Número de componentes conectados: 2
+Componente 1: 0 1 2
+Componente 2: 3 4 5
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <iso646.h>
+
+// Definição das estruturas de dados para o grafo
+typedef struct no {
+    int v;
+    struct no* next;
+} no;
+
+typedef struct grafo {
+    no **adj;
+    int n;
+} grafo;
+
+// Função para criar um novo grafo
+grafo *cria_grafo(int v) {
+    grafo *g = malloc(sizeof(grafo));
+    g->n = v;
+    g->adj = malloc(v * sizeof(no*));
+
+    for(int i = 0; i < v; ++i)
+        g->adj[i] = NULL;
+
+    return g;
+}
+
+// Função para inserir um novo nó na lista de adjacência
+no *insere_list(no *list, int u) {
+    no *novo = malloc(sizeof(no));
+    novo->v = u;
+    novo->next = list;
+    return novo;
+}
+
+// Função para inserir uma aresta no grafo
+void insere_aresta(grafo *g, int u, int v) {
+    g->adj[u] = insere_list(g->adj[u], v);
+    g->adj[v] = insere_list(g->adj[v], u);
+}
+
+// Função de busca em profundidade (DFS) para encontrar componentes conectados
+void dfs(grafo *g, int v, int *vis, int *comp, int count) {
+    vis[v] = 1;
+    comp[v] = count;
+    no *adj = g->adj[v];
+    while(adj) {
+        if (not vis[adj->v]) {
+            dfs(g, adj->v, vis, comp, count);
+        }
+        adj = adj->next;
+    }
+}
+
+int main(void) {
+    int v, e;
+    scanf("%d %d", &v, &e);
+
+    grafo *G = cria_grafo(v);
+    int *vis = calloc(v, sizeof(int));
+    int *components = calloc(v, sizeof(int));
+    int count = 0;
+
+    // Lendo as arestas
+    for (int i = 0; i < e; ++i) {
+        int u, w;
+        scanf("%d %d", &u, &w);
+        insere_aresta(G, u, w);
+    }
+
+    // Encontrando componentes conectados
+    for (int i = 0; i < v; ++i) {
+        if (not vis[i]) {
+            dfs(G, i, vis, components, count);
+            ++count;
+        }
+    }
+
+    // Imprimindo os resultados
+    printf("Numero de componentes conectados: %d\n", count);
+    for (int a = 0; a < count; ++a) {
+        printf("Componente %d: ", a + 1);
+        for (int i = 0; i < v; ++i) {
+            if (components[i] == a) {
+                printf("%d ", i);
+            }
+        }
+        printf("\n");
+    }
+
+    return 0;
+}