fix(guide): simplify directory structure

guide/portuguese/algorithms/graph-algorithms/breadth-first-search/index.md

@@ -0,0 +1,125 @@
+---
+title: Breadth First Search (BFS)
+localeTitle: Largura da Primeira Pesquisa (BFS)
+---
+## Largura da Primeira Pesquisa (BFS)
+
+Largura A primeira pesquisa é um dos algoritmos gráficos mais simples. Ele percorre o gráfico verificando primeiro o nó atual e expandindo-o adicionando seus sucessores ao próximo nível. O processo é repetido para todos os nós no nível atual antes de passar para o próximo nível. Se a solução for encontrada, a pesquisa será interrompida.
+
+### Visualização
+
+![](https://upload.wikimedia.org/wikipedia/commons/4/46/Animated_BFS.gif)
+
+### Avaliação
+
+Complexidade do espaço: O (n)
+
+Pior complexidade do tempo de caso: O (n)
+
+Largura A primeira pesquisa é concluída em um conjunto finito de nós e é ideal se o custo de mover de um nó para outro é constante.
+
+### Código C ++ para implementação do BFS
+
+```cpp
+// Program to print BFS traversal from a given 
+ // source vertex. BFS(int s) traverses vertices 
+ // reachable from s. 
+ #include<iostream> 
+ #include <list> 
+ 
+ using namespace std; 
+ 
+ // This class represents a directed graph using 
+ // adjacency list representation 
+ class Graph 
+ { 
+    int V;    // No. of vertices 
+ 
+    // Pointer to an array containing adjacency 
+    // lists 
+    list<int> *adj; 
+ public: 
+    Graph(int V);  // Constructor 
+ 
+    // function to add an edge to graph 
+    void addEdge(int v, int w); 
+ 
+    // prints BFS traversal from a given source s 
+    void BFS(int s); 
+ }; 
+ 
+ Graph::Graph(int V) 
+ { 
+    this->V = V; 
+    adj = new list<int>[V]; 
+ } 
+ 
+ void Graph::addEdge(int v, int w) 
+ { 
+    adj[v].push_back(w); // Add w to v's list. 
+ } 
+ 
+ void Graph::BFS(int s) 
+ { 
+    // Mark all the vertices as not visited 
+    bool *visited = new bool[V]; 
+    for(int i = 0; i < V; i++) 
+        visited[i] = false; 
+ 
+    // Create a queue for BFS 
+    list<int> queue; 
+ 
+    // Mark the current node as visited and enqueue it 
+    visited[s] = true; 
+    queue.push_back(s); 
+ 
+    // 'i' will be used to get all adjacent 
+    // vertices of a vertex 
+    list<int>::iterator i; 
+ 
+    while(!queue.empty()) 
+    { 
+        // Dequeue a vertex from queue and print it 
+        s = queue.front(); 
+        cout << s << " "; 
+        queue.pop_front(); 
+ 
+        // Get all adjacent vertices of the dequeued 
+        // vertex s. If a adjacent has not been visited, 
+        // then mark it visited and enqueue it 
+        for (i = adj[s].begin(); i != adj[s].end(); ++i) 
+        { 
+            if (!visited[*i]) 
+            { 
+                visited[*i] = true; 
+                queue.push_back(*i); 
+            } 
+        } 
+    } 
+ } 
+ 
+ // Driver program to test methods of graph class 
+ int main() 
+ { 
+    // Create a graph given in the above diagram 
+    Graph g(4); 
+    g.addEdge(0, 1); 
+    g.addEdge(0, 2); 
+    g.addEdge(1, 2); 
+    g.addEdge(2, 0); 
+    g.addEdge(2, 3); 
+    g.addEdge(3, 3); 
+ 
+    cout << "Following is Breadth First Traversal " 
+         << "(starting from vertex 2) \n"; 
+    g.BFS(2); 
+ 
+    return 0; 
+ } 
+```
+
+#### Mais Informações:
+
+[Gráficos](https://github.com/freecodecamp/guides/computer-science/data-structures/graphs/index.md)
+
+[Primeira pesquisa de profundidade (DFS)](https://github.com/freecodecamp/guides/tree/master/src/pages/algorithms/graph-algorithms/depth-first-search/index.md)

guide/portuguese/algorithms/graph-algorithms/depth-first-search/index.md

@@ -0,0 +1,105 @@
+---
+title: Depth First Search (DFS)
+localeTitle: Primeira pesquisa de profundidade (DFS)
+---
+## Primeira pesquisa de profundidade (DFS)
+
+Profundidade A primeira pesquisa é um dos algoritmos gráficos mais simples. Ele percorre o gráfico verificando primeiro o nó atual e, em seguida, movendo-se para um de seus sucessores para repetir o processo. Se o nó atual não tiver um sucessor para verificar, retornamos ao predecessor e o processo continua (mudando para outro sucessor). Se a solução for encontrada, a pesquisa será interrompida.
+
+### Visualização
+
+![](https://upload.wikimedia.org/wikipedia/commons/7/7f/Depth-First-Search.gif)
+
+### Implementação (C ++ 14)
+
+\`\` \`c ++
+
+# incluir
+
+# incluir
+
+# incluir
+
+# incluir
+
+usando namespace std;
+
+class Graph { na TV; // número de vértices
+```
+// pointer to a vector containing adjacency lists 
+ vector < int > *adj; 
+```
+
+público: Gráfico (int v); // Construtor
+```
+// function to add an edge to graph 
+ void add_edge(int v, int w); 
+ 
+ // prints dfs traversal from a given source `s` 
+ void dfs(); 
+ void dfs_util(int s, vector < bool> &visited); 
+```
+
+};
+
+Gráfico :: Gráfico (int v) { isso -> v = v; adj = novo vetor <int> \[v\]; }
+
+void Graph :: add _edge (int u, int v) { adj \[u\] .push de_ volta (v); // adiciona v à lista de u adj \[v\] .push de _volta (v); // adicione u à lista de v (remova essa declaração se o gráfico for direcionado!) } void Graph :: dfs () { // visited vector - para acompanhar os nós visitados durante o DFS vetor <bool> visitado (v, falso); // marcando todos os nós / vértices como não visitados para (int i = 0; i <v; i ++) if (! visitou \[i\]) dfs_ util (i, visitado); } // observe o uso de chamada por referência aqui! void Graph :: dfs\_util (int s, vetor <bool> e visitado) { // marcar o nó / vértice atual como visitado visitou \[s\] = verdadeiro; // saída para a saída padrão (tela) cout << s << "";
+```
+// traverse its adjacency list and recursively call dfs_util for all of its neighbours! 
+ // (only if the neighbour has not been visited yet!) 
+ for(vector < int > :: iterator itr = adj[s].begin(); itr != adj[s].end(); itr++) 
+    if(!visited[*itr]) 
+        dfs_util(*itr, visited); 
+```
+
+}
+
+int main () { // cria um gráfico usando a classe Graph que definimos acima Gráfico g (4); g.add _edge (0, 1); g.add_ edge (0, 2); g.add _edge (1, 2); g.add_ edge (2, 0); g.add _edge (2, 3); g.add_ edge (3, 3);
+```
+cout << "Following is the Depth First Traversal of the provided graph" 
+     << "(starting from vertex 0): "; 
+ g.dfs(); 
+ // output would be: 0 1 2 3 
+ return 0; 
+```
+
+}
+```
+### Evaluation 
+ 
+ Space Complexity: O(n) 
+ 
+ Worse Case Time Complexity: O(n) 
+ Depth First Search is complete on a finite set of nodes. I works better on shallow trees. 
+ 
+ ### Implementation of DFS in C++ 
+```
+
+c ++
+
+# incluir
+
+# incluir
+
+# incluir
+
+usando namespace std;
+
+struct graph { na TV; bool \* _adj; público: Gráfico (int vcount); void addEdge (int u, int v); void deleteEdge (int u, int v); vetor_ _DFS (int s); void DFSUtil (int s, vetor_ _& dfs, vetor_ _&visitou); }; Gráfico :: Graph (int vcount) { isto-> v = vcount; this-> adj = novo bool_ \[vcount\]; para (int i = 0; i
+
+void Graph :: addEdge (int u, int w) { this-> adj \[u\] \[w\] = verdadeiro; isto-> adj \[w\] \[u\] = verdadeiro; }
+
+void Graph :: deleteEdge (int u, int w) { isto-> adj \[u\] \[w\] = falso; isto-> adj \[w\] \[u\] = falso; }
+
+void Graph :: DFSUtil (int s, vetor & dfs, vetor &visitou){ visitou \[s\] = verdadeiro; dfs.push\_back (s); para (int i = 0; i v; i ++) { if (this-> adj \[s\] \[i\] == verdadeiro && visitado \[i\] == falso) DFSUtil (i, dfs, visitado); } }
+
+vetor Gráfico :: DFS (int s) { vetor visitado (this-> v); vetor dfs; DFSUtil (s, dfs, visitado); return dfs; } \`\` \`
+
+#### Mais Informações:
+
+[Gráficos](https://github.com/freecodecamp/guides/computer-science/data-structures/graphs/index.md)
+
+[Largura da Primeira Pesquisa (BFS)](https://github.com/freecodecamp/guides/tree/master/src/pages/algorithms/graph-algorithms/breadth-first-search/index.md)
+
+[Primeira pesquisa de profundidade (DFS) - Wikipedia](https://en.wikipedia.org/wiki/Depth-first_search)

guide/portuguese/algorithms/graph-algorithms/dijkstra/index.md

@@ -0,0 +1,95 @@
+---
+title: Dijkstra's Algorithm
+localeTitle: Algoritmo de Dijkstra
+---
+# Algoritmo de Dijkstra
+
+Algoritmo de Dijkstra é um algoritmo gráfico apresentado por EW Dijkstra. Ele encontra o caminho mais curto de fonte única em um gráfico com bordas não negativas (por quê?)
+
+Criamos 2 arrays: visited e distance, que registram se um vértice é visitado e qual é a distância mínima do vértice fonte, respectivamente. A matriz inicialmente visitada é designada como falsa e a distância como infinita.
+
+Nós começamos a partir do vértice fonte. Deixe o vértice atual ser u e seus vértices adjacentes sejam v. Agora, para cada v que é adjacente a u, a distância é atualizada se não tiver sido visitada antes e a distância de u for menor que sua distância atual. Em seguida, selecionamos o próximo vértice com a menor distância e que não foi visitado.
+
+Fila de prioridade é frequentemente usada para atender a esse último requisito no menor período de tempo. Abaixo está uma implementação da mesma ideia usando a fila de prioridades em Java.
+
+```java
+import java.util.*; 
+ public class Dijkstra { 
+    class Graph { 
+    LinkedList<Pair<Integer>> adj[]; 
+    int n; // Number of vertices. 
+    Graph(int n) { 
+        this.n = n; 
+        adj = new LinkedList[n]; 
+        for(int i = 0;i<n;i++) adj[i] = new LinkedList<>(); 
+    } 
+    // add a directed edge between vertices a and b with cost as weight 
+    public void addEdgeDirected(int a, int b, int cost) { 
+        adj[a].add(new Pair(b, cost)); 
+    } 
+    public void addEdgeUndirected(int a, int b, int cost) { 
+        addEdgeDirected(a, b, cost); 
+        addEdgeDirected(b, a, cost); 
+    } 
+    } 
+    class Pair<E> { 
+    E first; 
+    E second; 
+    Pair(E f, E s) { 
+        first = f; 
+        second = s; 
+    } 
+    } 
+ 
+    // Comparator to sort Pairs in Priority Queue 
+    class PairComparator implements Comparator<Pair<Integer>> { 
+    public int compare(Pair<Integer> a, Pair<Integer> b) { 
+        return a.second - b.second; 
+    } 
+    } 
+ 
+    // Calculates shortest path to each vertex from source and returns the distance 
+    public int[] dijkstra(Graph g, int src) { 
+    int distance[] = new int[gn]; // shortest distance of each vertex from src 
+    boolean visited[] = new boolean[gn]; // vertex is visited or not 
+    Arrays.fill(distance, Integer.MAX_VALUE); 
+    Arrays.fill(visited, false); 
+    PriorityQueue<Pair<Integer>> pq = new PriorityQueue<>(100, new PairComparator()); 
+        pq.add(new Pair<Integer>(src, 0)); 
+    distance[src] = 0; 
+    while(!pq.isEmpty()) { 
+        Pair<Integer> x = pq.remove(); // Extract vertex with shortest distance from src 
+        int u = x.first; 
+        visited[u] = true; 
+        Iterator<Pair<Integer>> iter = g.adj[u].listIterator(); 
+        // Iterate over neighbours of u and update their distances 
+        while(iter.hasNext()) { 
+        Pair<Integer> y = iter.next(); 
+        int v = y.first; 
+        int weight = y.second; 
+        // Check if vertex v is not visited 
+        // If new path through u offers less cost then update distance array and add to pq 
+        if(!visited[v] && distance[u]+weight<distance[v]) { 
+            distance[v] = distance[u]+weight; 
+            pq.add(new Pair(v, distance[v])); 
+        } 
+        } 
+    } 
+    return distance; 
+    } 
+ 
+    public static void main(String args[]) { 
+    Dijkstra d = new Dijkstra(); 
+    Dijkstra.Graph g = d.new Graph(4); 
+    g.addEdgeUndirected(0, 1, 2); 
+    g.addEdgeUndirected(1, 2, 1); 
+    g.addEdgeUndirected(0, 3, 6); 
+    g.addEdgeUndirected(2, 3, 1); 
+    g.addEdgeUndirected(1, 3, 3); 
+ 
+    int dist[] = d.dijkstra(g, 0); 
+    System.out.println(Arrays.toString(dist)); 
+    } 
+ } 
+
+```

guide/portuguese/algorithms/graph-algorithms/floyd-warshall-algorithm/index.md

@@ -0,0 +1,48 @@
+---
+title: Floyd Warshall Algorithm
+localeTitle: Algoritmo de Floyd Warshall
+---
+## Algoritmo de Floyd Warshall
+
+O algoritmo de Floyd Warshall é um ótimo algoritmo para encontrar a menor distância entre todos os vértices no gráfico. Ele tem um algoritmo muito conciso e complexidade de tempo O (V ^ 3) (onde V é o número de vértices). Pode ser usado com pesos negativos, embora ciclos de peso negativos não devam estar presentes no gráfico.
+
+### Avaliação
+
+Complexidade do espaço: O (V ^ 2)
+
+Pior complexidade do tempo de caso: O (V ^ 3)
+
+### Implementação em Python
+
+```python
+# A large value as infinity 
+ inf = 1e10 
+ 
+ def floyd_warshall(weights): 
+    V = len(weights) 
+    distance_matrix = weights 
+    for k in range(V): 
+        next_distance_matrix = [list(row) for row in distance_matrix] # make a copy of distance matrix 
+        for i in range(V): 
+            for j in range(V): 
+                # Choose if the k vertex can work as a path with shorter distance 
+                next_distance_matrix[i][j] = min(distance_matrix[i][j], distance_matrix[i][k] + distance_matrix[k][j]) 
+        distance_matrix = next_distance_matrix # update 
+    return distance_matrix 
+ 
+ # A graph represented as Adjacency matrix 
+ graph = [ 
+    [0, inf, inf, -3], 
+    [inf, 0, inf, 8], 
+    [inf, 4, 0, -2], 
+    [5, inf, 3, 0] 
+ ] 
+ 
+ print(floyd_warshall(graph)) 
+```
+
+#### Mais Informações:
+
+[Gráficos](https://github.com/freecodecamp/guides/computer-science/data-structures/graphs/index.md)
+
+[Floyd Warshall - Wikipédia, a enciclopédia livre](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm)

guide/portuguese/algorithms/graph-algorithms/index.md

@@ -0,0 +1,23 @@
+---
+title: Graph algorithms
+localeTitle: Algoritmos gráficos
+---
+## Algoritmos gráficos
+
+Algoritmos gráficos são um conjunto de instruções que atravessam (visitas de um gráfico).
+
+Alguns algoritmos são usados ​​para encontrar um nó específico ou o caminho entre dois nós especificados.
+
+### Por que os algoritmos gráficos são importantes?
+
+Os gráficos são estruturas de dados muito úteis que podem ser modelar vários problemas. Esses algoritmos têm aplicativos diretos em sites de redes sociais, modelagem de máquinas de estado e muito mais.
+
+### Algoritmos comuns de grafos
+
+Alguns dos algoritmos gráficos mais comuns são:
+
+[Gráficos](https://github.com/freecodecamp/guides/computer-science/data-structures/graphs/index.md)
+
+[Largura da Primeira Pesquisa (BFS)](https://github.com/freecodecamp/guides/tree/master/src/pages/algorithms/graph-algorithms/breadth-first-search/index.md)
+
+[Primeira pesquisa de profundidade (DFS)](https://github.com/freecodecamp/guides/tree/master/src/pages/algorithms/graph-algorithms/depth-first-search/index.md)