Luiz Schons – Algoritmos

Algoritmo de Dijkstra

Mon, 29 Jul 2024 00:00:00 -0300

Edsger W. Dijkstra foi um cientista da computação holandês que fez contribuições significativas para a ciência da computação. Ele é mais conhecido por desenvolver o algoritmo de Dijkstra, que resolve o problema do caminho menos custoso em um grafo direcionado ou não direcionado com arestas não negativas.

Mas antes de falar sobre o algoritmo de Dijkstra, vamos falar sobre o algoritmo de Pesquisa em Largura.

Pesquisa em Largura

Trabalhar com grafos é uma tarefa comum em computação. Um dos problemas mais comuns é encontrar o menor caminho entre dois vértices em um grafo. O algoritmo de Pesquisa em Largura mostra como encontrar o menor caminho em um grafo, como por exemplo, o caminho mais curto entre duas cidades em um mapa que tem cidades como vértices e estradas como arestas.

Imagine que precisamos sair de A para chegar em G. O algoritmo de Pesquisa em Largura nos ajuda a encontrar o menor caminho. O algoritmo começa visitando o vértice de origem (A) e então explora todos os vértices vizinhos. Depois disso, explora os vértices que estão a dois passos de distância e assim por diante.

No nosso caso o menor caminho é A -> B -> E -> G.

Nesse caso, temos somente 3 passos para chegar em G.

Algoritmo de Dijkstra

Mas e se as arestas tiverem pesos? O algoritmo de Pesquisa em Largura não funciona mais. O algoritmo de Dijkstra é um algoritmo que encontra o caminho mais barato em um grafo direcionado ou não direcionado, com arestas que possuem pesos. O algoritmo de Dijkstra mantém duas listas: uma lista de vértices visitados e uma lista de vértices não visitados. Ele seleciona o vértice não visitado mais próximo do vértice de origem, marca-o como visitado e atualiza os pesos dos vértices vizinhos.

Vamos adaptar o exemplo anterior para incluir pesos nas arestas.

Agora temos pesos em cada aresta, e nosso desafio é encontrar o caminho em que a soma dos pesos seja menor.

Vamos aplicar o algoritmo de Dijkstra para encontrar o menor caminho de A para G.

Começamos em A e olhamos os vizinhos dele: chegar em B custa 10 e chegar em C custa 5.

Vértice Distância de A Caminho
A 0 A
B 10 A → B
C 5 A → C
O vértice não visitado mais próximo de A é C (5). Visitamos C e atualizamos os vizinhos dele: D passa a custar 7 (5 + 2) e F passa a custar 9 (5 + 4).

Vértice Distância de A Caminho
A 0 A
B 10 A → B
C 5 A → C
D 7 A → C → D
F 9 A → C → F
O próximo mais próximo é D (7). Passando por D, E custa 8 (7 + 1). F custaria 13 (7 + 6), que é pior que 9, então F não muda.

Vértice Distância de A Caminho
A 0 A
B 10 A → B
C 5 A → C
D 7 A → C → D
F 9 A → C → F
E 8 A → C → D → E
O próximo é E (8). Passando por E, G custa 10 (8 + 2). Visitar F e B depois não melhora nenhuma distância, então o algoritmo termina.

Vértice Distância de A Caminho
A 0 A
B 10 A → B
C 5 A → C
D 7 A → C → D
F 9 A → C → F
E 8 A → C → D → E
G 10 A → C → D → E → G

Vértice	Distância de A	Caminho
A	0	A
B	10	A → B
C	5	A → C

Vértice	Distância de A	Caminho
A	0	A
B	10	A → B
C	5	A → C
D	7	A → C → D
F	9	A → C → F

Vértice	Distância de A	Caminho
A	0	A
B	10	A → B
C	5	A → C
D	7	A → C → D
F	9	A → C → F
E	8	A → C → D → E

Vértice	Distância de A	Caminho
A	0	A
B	10	A → B
C	5	A → C
D	7	A → C → D
F	9	A → C → F
E	8	A → C → D → E
G	10	A → C → D → E → G

O menor caminho de A para G é A -> C -> D -> E -> G, com custo total 10.

Aplicando isso com PHP

Vamos criar um exemplo prático em PHP para aplicar o algoritmo de Dijkstra.

$graph = [
 'A' => ['B' => 10, 'C' => 5],
 'B' => ['E' => 8, 'D' => 3],
 'C' => ['D' => 2, 'F' => 4],
 'D' => ['E' => 1, 'F' => 6],
 'E' => ['G' => 2],
 'F' => ['E' => 1],
 'G' => []
];

function dijkstra(array $graph, string $source, string $target): array
{
 $dist = array_fill_keys(array_keys($graph), INF);
 $prev = array_fill_keys(array_keys($graph), null);
 $dist[$source] = 0;

 // SplPriorityQueue devolve primeiro a maior prioridade,
 // então usamos a distância negativa para pegar o vértice mais próximo.
 $queue = new SplPriorityQueue();
 $queue->insert($source, 0);

 while (!$queue->isEmpty()) {
 $u = $queue->extract();

 foreach ($graph[$u] as $v => $cost) {
 $alt = $dist[$u] + $cost;
 if ($alt < $dist[$v]) {
 $dist[$v] = $alt;
 $prev[$v] = $u;
 $queue->insert($v, -$alt);
 }
 }
 }

 $path = [];
 for ($u = $target; $u !== null; $u = $prev[$u]) {
 array_unshift($path, $u);
 }

 return $path;
}

$path = dijkstra($graph, 'A', 'G');
echo implode(' -> ', $path); // A -> C -> D -> E -> G

Segue o passo a passo da execução do algoritmo:

Inicializamos as distâncias e a fila de prioridade.
Inicializamos a distância do vértice de origem como 0.
Enquanto a fila de prioridade não estiver vazia, extraímos o vértice com a menor distância.
Para cada vértice vizinho, calculamos a distância alternativa e atualizamos a distância se for menor.
Construímos o caminho percorrendo os vértices anteriores.
Retornamos o caminho.

Conclusão

Com o aumento do uso de IA, Machine Learning e Big Data, o conceito de grafos se tornou cada vez mais importante. O algoritmo de Dijkstra é um dos algoritmos mais importantes para encontrar o menor caminho em um grafo. Espero que você tenha entendido como o algoritmo de Dijkstra funciona e como ele pode ser aplicado em um cenário do mundo real. Se você gostou desse artigo, deixe um comentário e compartilhe com seus amigos. Até a próxima!

Tabelas Hash

Wed, 06 Mar 2024 00:00:00 -0300

Uma tabela hash é uma estrutura de dados que associa chaves de pesquisa a valores.

Sua principal função é, a partir de uma chave simples, fazer uma busca rápida e eficiente para encontrar o valor desejado.

1. Funções Hash

1.1. Introdução

A função hash é uma função que, a partir de uma entrada de dados, gera um valor numérico que identifica a posição de um elemento em uma tabela hash.

Nós já vimos algumas outras estruturas de dados aqui nesse perfil, como buscar um elemento em uma lista encadeada ou em uma árvore binária, e vimos que a complexidade dessas operações é O(n) e O(log n), respectivamente.

A tabela hash, por sua vez, consegue fazer essa busca em O(1), ou seja, em tempo constante.

Isso significa que, não importa o tamanho da tabela, a busca será feita no mesmo tempo.

1.2. Exemplo

Muitas vezes, a função hash é usada para criar um índice para um array, e é por isso que a função hash deve ser rápida e eficiente.

Desenvolvi uma função hash muito simples, que pega uma palavra e retorna um número que representa essa palavra.

package main

import (
 "fmt"
)

func main() {
 for {
 run()
 }
}

func run(){
 array_palavras := [10000]string{}
 fmt.Println("Digite uma palavra para ser hasheada")
 var palavra string
 fmt.Scanln(&palavra)
 hash_palavra := fake_hash(palavra)
 fmt.Println("A palavra", palavra, "tem o hash", hash_palavra)
 array_palavras[hash_palavra] = palavra
 fmt.Println("A palavra", palavra, "foi adicionada ao array na posicao", hash_palavra)
 fmt.Println("Digite um hash para buscar a palavra correspondente")
 var hash int
 fmt.Scanln(&hash)
 fmt.Println("A palavra correspondente ao hash", hash, "é", array_palavras[hash])
}

func fake_hash(palavra string) int {
 hash := 0
 for i := 0; i < len(palavra); i++ {
 hash += int(palavra[i])
 }
 return hash
}

Nesse exemplo, a função fake_hash pega a palavra e soma os valores ASCII de cada caractere, retornando um número que representa a palavra.

Mas fique tranquilo, provavelmente você não vai precisar criar uma função hash, pois as linguagens de programação já possuem funções hash prontas e otimizadas.

Pode ser que na sua linguagem de programação a função hash seja chamada de outra coisa, como “map” ou “dicionário”, mas o conceito é o mesmo.

2. Usabilidade

2.1. Lista Telefônica

Um exemplo clássico de uso de tabela hash é a lista telefônica.

Imagine que você quer encontrar o número de telefone de uma pessoa.

Se a lista telefônica fosse uma lista encadeada, você teria que percorrer toda a lista até encontrar o nome da pessoa.

Se fosse uma árvore binária, você teria que percorrer a árvore até encontrar o nome da pessoa.

Mas, como a lista telefônica é uma tabela hash, você pode encontrar o número de telefone de uma pessoa em tempo constante, ou seja, em O(1).

Vamos entender mais sobre isso.

Ao adicionar um nome e um número de telefone à lista telefônica, a função hash é usada para gerar um índice para esse nome.

Quando você quer encontrar o número de telefone de uma pessoa, a função hash é usada para gerar o índice correspondente ao nome da pessoa, e o número de telefone é retornado.

Dessa forma:

package main

import (
 "fmt"
)
func main() {
 lista_telefonica := make(map[string]string)
 lista_telefonica["João"] = "1234-5678"
 lista_telefonica["Maria"] = "8765-4321"
 lista_telefonica["José"] = "4321-5678"
 lista_telefonica["Ana"] = "5678-4321"
 fmt.Println("O número de telefone de João é", lista_telefonica["João"])
 fmt.Println("O número de telefone de Maria é", lista_telefonica["Maria"])
 fmt.Println("O número de telefone de José é", lista_telefonica["José"])
 fmt.Println("O número de telefone de Ana é", lista_telefonica["Ana"])
}

Nesse exemplo, a função hash é usada para gerar um índice para cada nome, e o número de telefone é retornado em tempo constante.

2.2. DNS

Outro exemplo clássico de uso de tabela hash é o DNS (Domain Name System).

O DNS é um sistema que traduz nomes de domínio da Internet em endereços IP.

Imagine que você quer acessar um site, como www.google.com.

Se o DNS não fosse uma tabela hash, você teria que percorrer toda a lista de domínios até encontrar o nome do site, imagina o tempo que isso levaria.

Mas, como o DNS é uma tabela hash, você pode encontrar o endereço IP de um site em tempo constante, ou seja, em O(1).

Vamos entender mais sobre isso com um exemplo.

package main

import (
 "fmt"
)
func main() {
 dns := make(map[string]string)
 dns["www.google.com"] = "192.168.5.5"
 dns["www.facebook.com"] = "192.168.40.21"
 dns["www.twitter.com"] = "192.168.11.11"
 fmt.Println("O endereço IP de www.google.com é", dns["www.google.com"])
 fmt.Println("O endereço IP de www.facebook.com é", dns["www.facebook.com"])
 fmt.Println("O endereço IP de www.twitter.com é", dns["www.twitter.com"])
}

Entende como são exemplos bem similares? A ideia é a mesma, a tabela hash é usada para gerar um índice para cada nome, e o endereço IP é retornado em tempo constante.

3. Colisões

3.1. Introdução

Uma colisão ocorre quando duas chaves de pesquisa diferentes têm o mesmo valor hash.

Mas isso é possível? Como a função hash gera um valor único para cada chave de pesquisa?

Bom, a função hash não gera um valor único para cada chave de pesquisa, ela gera um valor que representa a chave de pesquisa.

E, como o número de chaves de pesquisa é muito maior do que o número de valores hash, é possível que duas chaves de pesquisa diferentes tenham o mesmo valor hash.

3.2. Tratamento de Colisões

Existem várias maneiras de tratar colisões, mas as duas mais comuns são:

Encadeamento
Endereçamento Aberto

3.2.1. Encadeamento

No encadeamento, cada entrada da tabela hash é uma lista encadeada.

Quando ocorre uma colisão, a chave de pesquisa é adicionada à lista encadeada correspondente.

Isso significa que, se duas chaves de pesquisa diferentes têm o mesmo valor hash, elas são adicionadas à mesma lista encadeada.

A principal vantagem do encadeamento é que ele é simples de implementar, mas a principal desvantagem é que ele pode ser ineficiente em termos de espaço e desempenho.

3.2.2. Endereçamento Aberto

No endereçamento aberto, quando ocorre uma colisão, a chave de pesquisa é adicionada a outra posição da tabela hash.

Isso significa que, se duas chaves de pesquisa diferentes têm o mesmo valor hash, a segunda chave de pesquisa é adicionada a outra posição da tabela hash.

A principal vantagem do endereçamento aberto é que ele é eficiente em termos de espaço e desempenho, mas a principal desvantagem é que ele é mais complexo de implementar.

4. Desempenho

4.1. Fator de Carga

O fator de carga é a razão entre o número de chaves de pesquisa e o número de posições da tabela hash.

Quanto maior o fator de carga, maior a probabilidade de colisões.

Por isso, é importante manter o fator de carga baixo, para garantir um bom desempenho da tabela hash.

Um fator de carga ideal é menor que 0,7, ou seja, menos de 70% das posições da tabela hash estão ocupadas.

4.1.1. Como Calcular o Fator de Carga

O fator de carga é calculado da seguinte forma:

NK = número de chaves de pesquisa
NP = número de posições da tabela hash

NK / NP = fator de carga

Por exemplo, se a tabela hash tem 100 posições e 70 chaves de pesquisa, o fator de carga é 0,7.

70 / 100 = 0,7

4.2. Redimensionamento

Quando o fator de carga é maior que 0,7, é necessário redimensionar a tabela hash.

O redimensionamento da tabela hash é feito da seguinte forma:

Crie uma nova tabela hash com o dobro do tamanho da tabela hash original
Adicione todas as chaves de pesquisa da tabela hash original à nova tabela hash
Descarte a tabela hash original

O redimensionamento da tabela hash é uma operação custosa, mas é necessária para garantir um bom desempenho da tabela hash.

5. SHA

SHA (Secure Hash Algorithm) é uma família de funções hash criptográficas.

Ela é uma ótima função hash, pois gera um valor único para cada chave de pesquisa.

SHA é amplamente utilizada em criptografia, segurança da informação e autenticação.

SHA é uma função hash muito segura, e é praticamente impossível encontrar duas chaves de pesquisa diferentes com o mesmo valor hash.

Uma das principais vantagens de SHA é que ela é rápida, eficiente e unidirecional, ou seja, é fácil calcular o valor hash de uma chave de pesquisa, mas é praticamente impossível calcular a chave de pesquisa a partir do valor hash.

Segue um exemplo de como usar SHA em Go:

package main
import (
 "crypto/sha256"
 "fmt"
)

func main() {
 palavra := "hello"
 hash := sha256.Sum256([]byte(palavra))
 fmt.Printf("O hash de %s é %x\n", palavra, hash)
}

Nesse exemplo, a função hash SHA-256 é usada para gerar um valor hash para a palavra “hello”.

Mas se você quiser usar o SHA-256 para gerar a palavra “hello” a partir do valor hash, você não vai conseguir.

6. Conclusão

As tabelas hash são estruturas de dados muito eficientes para fazer buscas rápidas e eficientes.

Elas são amplamente utilizadas em aplicações do mundo real, como listas telefônicas, DNS, criptografia e segurança da informação.

Você aprendeu sobre funções hash, usabilidade, colisões, desempenho e SHA.

Nunca implemente uma função hash e use em produção, sempre use funções hash prontas e otimizadas da sua linguagem de programação.

Espero que você tenha aprendido bastante sobre tabelas hash, e que você possa aplicar esse conhecimento em suas aplicações do mundo real.

Se você tiver alguma dúvida ou sugestão, deixe nos comentários.

Até a próxima!

Quicksort

Wed, 28 Feb 2024 00:00:00 -0300

Quicksort é um algoritmo de ordenação muito eficiente, inventado por C.A.R. Hoare em 1960. Ele é amplamente utilizado para ordenação de arrays. O algoritmo que apresentamos a seguir é uma versão recursiva do Quicksort que seleciona um elemento como pivô e particiona o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois. Os subarrays são então ordenados recursivamente.

Mas antes de começarmos a falar sobre o algoritmo, você precisa entender o que são métodos de DC (Divisão e Conquista).

Métodos de DC

Métodos de DC são algoritmos que resolvem um problema dividindo-o em subproblemas, resolvendo os subproblemas recursivamente e combinando as soluções dos subproblemas para resolver o problema original.

Vamos ver um exemplo de um algoritmo que utiliza DC.

Exemplo

Imagina que você tenha um array de inteiros e quer saber a soma de todos os elementos desse array. Você pode resolver esse problema utilizando DC da seguinte forma:

Array: [1, 2, 3, 4, 5]

Qual é o caso base? O caso base é quando o array tem apenas um elemento. Nesse caso, a soma é o próprio elemento.

Como iremos chegar no caso base? Vamos remover um elemento e ver o que sobra.

Elemento removido	Array restante
1	[2, 3, 4, 5]
2	[3, 4, 5]
3	[4, 5]
4	[5]

Agora que chegamos no caso base, vamos resolver o problema. A soma de todos os elementos do array [5] é 5. Agora, vamos somar o 4 que removemos anteriormente. A soma de todos os elementos do array [4, 5] é 9. Agora, vamos somar o 3 que removemos anteriormente. A soma de todos os elementos do array [3, 9] é 12. E assim por diante.

Caso base	Soma
[5]	5
[4, 5]	9
[3, 9]	12
[2, 12]	14
[1, 14]	15

A soma de todos os elementos do array [1, 2, 3, 4, 5] é 15.

Esse é um caso simples de DC e muitos algoritmos utilizam esse conceito para resolver problemas.

Por que não usar um loop?

Você pode estar se perguntando por que não usar um loop para resolver esse problema. E a resposta é: você pode! Mas, em alguns casos, a solução utilizando DC é mais simples e mais fácil de entender.

Outro ponto importante é que, em algumas linguagens, principalmente as funcionais, não existe a estrutura de repetição (for, while, etc.). Então, a única forma de resolver um problema é utilizando DC.

Entendendo esse algoritmo, você consegue trabalhar com outras linguagens de programação e entender como elas funcionam.

Caso tenha alguma dúvida, busque por mais exemplos e tente resolver problemas utilizando DC.

Quicksort

Agora que você entendeu o que é DC, vamos falar sobre o Quicksort.

O Quicksort é um algoritmo de ordenação muito eficiente, inventado por C.A.R. Hoare em 1960. Ele é amplamente utilizado para ordenação de arrays. O algoritmo que apresentamos a seguir é uma versão recursiva do Quicksort que seleciona um elemento como pivô e particiona o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois. Os subarrays são então ordenados recursivamente.

Exemplo

Vamos ver um exemplo de como o Quicksort funciona.

Array
3, 6, 8, 10, 1, 2, 1

Passo 1: Escolha um elemento como pivô. Vamos escolher o 6.

Passo 2: Particione o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois.

Menores que 6	Pivô	Maiores que 6
3, 1, 2, 1	6	8, 10

Passo 3: Ordenar os subarrays recursivamente.

O que significa ordenar os subarrays recursivamente? Significa que vamos repetir os passos 1 e 2 para os subarrays, escolhendo um pivô e particionando o array.

Vamos escolher o 1 como pivô.

Menores que 1	Pivô	Maiores que 1
	1, 1	2, 3

Vamos escolher o 2 como pivô.

Menores que 2	Pivô	Maiores que 2
	2	3

Agora somos obrigados a escolher o 3 como pivô.

Menores que 3	Pivô	Maiores que 3
	3

Agora que chegamos no caso base, vamos ordenar os subarrays recursivamente.

Voltando agora os arrays até organizarmos o array da esquerda.

Menores que 6	Pivô	Maiores que 6
1, 1, 2, 3	6	8, 10

Agora vamos organizar o array da direita.

Array
8, 10

Passo 1: Escolha um elemento como pivô. Vamos escolher o 10.

Passo 2: Particione o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois.

Menores que 10	Pivô	Maiores que 10
8	10

Agora que chegamos no caso base, vamos ordenar os subarrays recursivamente.

Voltando agora os arrays até organizarmos o array da direita.

Array
8, 10

Agora que organizamos os subarrays, o array original está ordenado.

Array
1, 1, 2, 3, 6, 8, 10

Esse é um exemplo de como o Quicksort funciona.

Performance

Dentro do desenvolvimento de software, a performance é um fator muito importante e muitas vezes usamos a Notação Big O para descrever a eficiência de um algoritmo.

Caso você não conheça a Notação Big O, recomendo que você leia um artigo sobre o assunto que escrevi aqui nesse link: Notação Big O.

O desempenho do Quicksort é O(n log n) no melhor caso e O(n²) no pior caso.

E a performance vai depender do pivô que você escolher. Se você escolher um pivô que seja o menor ou o maior elemento do array, o desempenho do Quicksort será O(n²). Mas, se você escolher um pivô que seja o elemento do meio do array, a performance do Quicksort será O(n log n).

Mas como escolher o pivô? Existem várias formas de escolher o pivô e a escolha do pivô vai depender do seu problema. Uma forma de escolher o pivô é escolher o elemento do meio do array.

Dessa forma, eu fiz um repositório no github com a implementação do Quicksort em Go. Caso você queira ver a implementação, clique aqui.

Esse artigo é uma introdução ao Quicksort e espero que você tenha entendido como o algoritmo funciona, e agora se você escutar alguém falando sobre Quicksort, você vai entender do que se trata.

Lembre-se que a prática leva à perfeição e, quanto mais você praticar, mais você vai entender sobre o assunto.

Caso tenha alguma dúvida, busque por mais exemplos e tente resolver problemas utilizando Quicksort.

Espero que você tenha gostado do artigo e até a próxima!