diff --git a/Introdução à Análise de Algoritmos/EP 1/Resolução EP1 - IAA.md b/Introdução à Análise de Algoritmos/EP 1/Resolução EP1 - IAA.md new file mode 100644 index 0000000..219fc85 --- /dev/null +++ b/Introdução à Análise de Algoritmos/EP 1/Resolução EP1 - IAA.md @@ -0,0 +1,344 @@ +# Análise de algoritmos para a solução do Problema da Seleção + +> Por Guilherme de Abreu Barreto[^1] + +## Resumo + +É o objetivo deste relatório definir o *Problema da Seleção* e apresentar dois algoritmos passíveis de solucioná-lo. Compara-se as estratégias adotadas em cada algoritmo, assim como o tempo de execução previsto e experimental de cada qual. Com base nessas observações infere-se a eficiência relativa dos algoritmos. + +## Introdução + +O *Problema da Seleção* no contexto desta análise refere-se a necessidade de, para uma sequência de elementos $x_a, \dots, x_i, \dots, x_b$ onde $a \le i \le b$, sendo $a$ e $b$ sendo os índices inicial e final respectivamente, acessar o $i$-esimo elemento $x_i$ de acordo com um dado parâmetro. Iremos aqui admitir que $\forall x \in \Z$ e utilizaremos como critério o valor de $x$ de maneira a selecionar o $i$-esimo elemento de menor valor. Vamos abordar este problema de duas formas: + +Na primeira solução (solução `mergeSelect`) ordenaremos o conjunto de elementos em ordem crescente para, em seguida, acessar $a_i$ diretamente. + +Na segunda solução (solução `quickSelect`) continuamente particionaremos a sequência à partir de comparações com o valor de um elemento desta, o pivô. Isso até que, ou o pivô ao final do processo de partição corresponda ao índice $i$, ou o conjunto particionado avaliado tenha tamanho 1 (portanto, contendo somente o elemento de índice $i$). + +### Solução *mergeSelect* + +#### Definição + +O algoritmo aqui implementado para a ordenação do arranjo de valores inteiros é o *Merge Sort*, que dá nome a solução. Trata-se de um algoritmo de ordenação eficiente e estável pautado pela comparação de valores e baseado no paradigma da *Divisão e Conquista*. + +Conceitualmente, seu funcionamento se dá da seguinte maneira: + +1. Divide-se o arranjo em $n$ sub-arranjos de tamanho 1, sendo $n$ o tamanho do conjunto original a ser ordenado, pois uma lista de um único elemento trivialmente já se encontra ordenada; + +2. continuamente integra-se e ordena-se os sub-arranjos pré-ordenados para a par; até que + +3. resta apenas a lista original ordenada. A partir de então, para encontrar o $i$-ésimo menor elemento, basta referenciar o arranjo pelo índice $i$: `A[i]`. + + + +> Diagrama ilustrando os passos para execução do *Merge Sort* em uma sequência de 7 números inteiros.[^2] + +#### Implementação + +Minha implementação deste algoritmo para o presente problema é dado pelas seguintes funções: + +```c + 1 │ #define array int* + 2 │ + 3 │ void merge (array A, int pivot, int size) { + 4 │ int i, k, j = pivot, tmp[size]; + 5 │ + 6 │ for (i = k = 0; k < size; k++) + 7 │ tmp[k] = ((A[i] <= A[j] && i < pivot) || j == size) ? + 8 | A[i++] : A[j++]; + 9 │ for (k = 0; k < size; k++) + 10 │ A[k] = tmp[k]; + 11 │ } + 12 │ +``` + +```c + 13 │ void mergeSort (array A, int size) { + 14 │ int pivot; + 15 │ + 16 │ if (size <= 1) + 17 │ return; + 18 │ pivot = size / 2; + 19 │ mergeSort(A, pivot); + 20 │ mergeSort(A + pivot, size - pivot); + 21 │ merge(A, pivot, size); + 22 │ } +``` + +#### Correção + +Podemos aferir que o algoritmo acima é correto (isto é, adequado a produzir a solução) pois + +1. Nas linhas 19 e 20 subdivide-se a sequência em pares recursivamente, procedimento este que se repetirá até que restem apenas subconjuntos de 1 elemento e a função retorne na linha 17. + +2. Cada recursão anterior então acessa a função `merge` na linha 21. Esta integrará pares de conjuntos adjacentes ao índice `pivot` nas linhas 7 e 8, percorrendo-os cada qual desde seus respectivos índices iniciais `i` e `j` e posicionando o elemento de menor valor no índice $k$. Isso, seguro de que estes já estarão ordenados em ordem crescente dada a condição anterior. Este então retornará os elementos de ambos os conjuntos em ordem crescente na linha 10. + +3. O procedimento anterior se repete $(n - 1)$ vezes até que todos os pares ordenados combinados produzem a sequência original ordenada. + +Assim, o algoritmo corresponde a definição dada anteriormente. + +##### Teste empírico + +A correção do algoritmo foi testada manualmente para pequenos arranjos utilizando o programa `manual_test.c`[^4]. + +#### Tempo de Execução + +É possível afirmar que o tempo de execução $T(n)$ do *Merge Sort* para quaisquer entradas de mesmo tamanho $n$ é assintoticamente equivalente pois independentemente dos valores contidos na entrada, as mesmas operações de comparação (na linha 7) e atribuição (na linha 10) são executadas. Isto é, diferentemente do que é visto noutros algoritmos de ordenação tais quais o *Quick Sort* ou o *Insertion Sort*. Para estimar este tempo de execução, podemos recorrer ao *Teorema Mestre para recorrências de Divisão e Conquista*, por este ser um algoritmo do tipo *Divisão e Conquista*. Segundo Márcio Ribeiro (2021) o teorema mestre pode ser descrito nos seguintes termos: + +> Sejam $a \ge 1$, $b > 1$ e $T (n) = aT \left( \frac nb \right) + f (n)$, então: +> +> 1. se $f(n) \in O\left(n^{\log_b (a − \varepsilon)} \right)$ para algum $\varepsilon > 0$ então $T (n) \in \Theta(n^{\log_ba} )$; +> +> 2. se $f(n) ∈ Θ(n^{log_ba})$ então $T(n) \in \Theta(n^{\log_ba} \cdot \text{lg}(n))$; +> +> 3. se $f(n) \in \Omega \left(n^{\log_b (a + \varepsilon)} \right)$ para algum $\varepsilon > 0$ e se $af \left(\frac nb \right) \le cf(n)$ para algum $c < 1$ e todo $n$ suficientemente grande então $T(n) \in Θ(f (n))$ + +Temos que o tempo de execução $T(n)$ em função do tamanho $n$ da entrada do algoritmo *Merge Sort* é constante das linhas 14 à 18 mas varia nas linhas 19 e 20 ($T\left(\frac n2 \right)$ cada), e 21 ($cn$, para uma constante $c > 0$). Assim temos que a forma geral do tempo de execução é: + +$$ +T(n) = 2T\left(\frac n2 \right) + cn +$$ + +Ou seja, conforme a definição $aT \left( \frac nb \right) + f (n)$ tem-se que + +- $a = b = 2$; + +- $n^{\log_ba} = n^{log_22} = n$; + +- $f(n) = cn$, sendo $\Theta(cn) \equiv \Theta(n)$; + +- e portanto $f(n) \in \Theta(n^{\log_ba})$ pois $\Theta(n^{\log_ba}) = \Theta(n)$. + +Assim, temos pela aplicação do teorema que: + +$$ +T(n) \in \Theta(n^{\log_ba}\cdot \text{lg}(n)) \implies T(n) \in \Theta(n\cdot \text{lg}(n)) +$$ + +### Solução *quickSelect* + +#### Definição + +O algoritmo `quickSelect`, tal qual o algoritmo *Quick Sort*, foi desenvolvido por Tony Hoare e utiliza a mesma estratégia do último para comparar valores. + +Conceitualmente, seu funcionamento se dá da seguinte maneira: + +- Particiona-se a sequência à partir do valor de um elemento qualquer contido nessa, separando-a em dois subconjuntos contendo respectivamente + + - valores maiores ou iguais; + + - e menores que o pivô. + + Portanto, o pivô passa a ocupar uma posição intermediária às partições; + +- Se o pivô assume a posição do índice buscado ou resta apenas um único índice no conjunto particionado, a busca se encerra; senão repete-se o procedimento na partição aquela que contiver o índice $i$ (sendo este menor ou maior que o pivô). + +#### Implementação + +```c + 1 │ #define array int* + 2 │ + 3 │ void swap (int *a, int *b) { + 4 │ int tmp = *a; + 5 │ *a = *b; + 6 │ *b = tmp; + 7 │ } + 8 │ + 9 │ int partition (array A, int pivot, int size) { + 10 │ int i, j, lastIndex = size - 1; + 11 │ + 12 │ swap(&A[pivot], &A[lastIndex]); + 13 │ for (i = j = 0; i < lastIndex; i++) + 14 │ if (A[i] <= A[lastIndex]) + 15 │ swap(&A[i], &A[j++]); + 16 │ swap(&A[i], &A[j]); + 17 │ return j; + 18 │ } + 19 │ + 20 │ int * quickSelect (array A, int size, int i) { + 21 │ int pivot; + 22 │ + 23 │ if (size <= 1) + 24 │ return A; + 25 │ pivot = partition(A, i, size); + 26 │ if (A + pivot == A + i) + 27 │ return A + i; + 28 │ if (i < pivot) + 29 │ return quickSelect(A, pivot, i); + 30 │ pivot++; + 31 │ return quickSelect(A + pivot, size - pivot, i - pivot); + 32 │ } +``` + +#### Correção + +Podemos aferir que o algoritmo acima é correto pois + +1. Se a a entrada contiver um único elemento, este é o elemento devolvido — Este é o caso base. + +2. Senão, o conjunto é particionado na linha 24 e comparações são feitas nas linhas 25 para aferir se o índice foi encontrado no pivô ou, senão, na linha 27 determina-se em qual partição o procedimento de busca deve ser repetido até que as condições anteriores sejam satisfeitas. + +3. Como toda partição é menor que o conjunto que lhe deu origem, no pior caso eventualmente a partição avaliada será pequena o suficiente para corresponder ao caso base. + +##### Teste empírico + +A correção do algoritmo anterior foi testada manualmente para pequenos arranjos utilizando o programa `manual_test.c`[^5]. + +#### Tempo de Execução + +O tempo de execução deste algoritmo pode variar bastante em função do posicionamento do pivô ao final de cada procedimento de partição. Analisemos, portanto, aqueles que podem ser considerados o melhor, o pior, e o caso médio. + +##### Análise do melhor caso + +O melhor caso para a execução deste algoritmo é aquele em que o $i$-ésimo menor elemento do arranjo já se encontra na $i$-ésima posição ao iniciarmos a busca. Assim, a partição será feita com este elemento enquanto pivô na linha 13, retornando o mesmo a sua posição inicial na linha 16, e a busca estará findada tendo percorrido o arranjo uma única vez na linha 27. Desta forma, o tempo de busca em função do tamanho da entrada escalaria de forma estritamente linear. Ou seja, $T(n) \in \Theta(n)$. + +##### Análise do pior caso + +O pior caso para a execução deste algoritmo seria aquele onde o usuário busca o menor valor de um arranjo que encontra-se perfeitamente em ordem crescente **à partir do segundo elemento**. Assim, o primeiro elemento tem o maior valor e cada processo de partição se dá de forma em que o pivô é o $(n - (i - 1))$ maior elemento, produzindo assim partições de tamanho menor que a anterior em apenas uma unidade. Assim o arranjo é percorrido de maneira a realizar um número de $S_n$ de comparações na linha 14 equivalente à: + +$$ +S_n = n + (n - 1) + (n - 2) + \dots + 1 = \frac{n(n + 1)}2 = \frac{n^2 + n}2 +$$ + +Ou seja, o tempo de execução do algoritmo restaria em ordem quadrática: $T(n) \in \Theta(n^2)$. + +##### Análise do caso médio + +Aplicando-se o Teorema Mestre conseguimos avaliar o **caso médio**, pois este admite que recursões são feitas em conjuntos menores de igual tamanho entre si. Fosse sempre este o caso com este algoritmo o índice $i$ ser menor ou maior que aquele do pivô não afetaria o tempo de execução da recursão seguinte, o qual também não seria nem muito pequeno (com o tamanho da partição seguinte abaixo da média) ou muito grande (com o tamanho da partição seguinte acima da média). + +Temos que o tempo de execução $T(n)$ em função do tamanho $n$ da entrada do algoritmo *quickSelect* é constante nas linhas 20 à 23, 25 à 26 e 27 mas varia na linha 24 ($cn$, para uma constante $c > 0$) e nas linhas 28 e 29 ($T\left(\frac n2 \right)$ cada), das quais apenas uma delas é executada condicionalmente. Assim temos que a forma geral do tempo de execução é: + +$$ +T(n) = T\left(\frac n2 \right) + cn +$$ + +Ou seja, conforme a definição $aT \left( \frac nb \right) + f (n)$ tem-se que + +- $a = 1$ e $b = 2$; + +- $n^{\log_ba} = n^{log_21} = n^0 = 1$; + +- $f(n) = cn$, sendo $\Theta(cn) \equiv \Theta(n)$; + +- e portanto $f(n) \in \Omega \left( n^{\log_b(a+ \varepsilon)} \right)$ pois $\Omega \left(n^{\log_2(1 + 1)} \right) = \Omega(n)$. + +Assim, temos pela aplicação do teorema que: + +$$ +T(n) \in \Theta(cn) \implies T(n) \in \Theta(n) +$$ + +Vemos então que teoricamente o caso médio aproxima-se mais da situação observada no melhor caso que do pior caso e, para valores de $n$ suficientemente grandes, oferece melhor desempenho com relação a solução `mergeSelect`. + +## Objetivo + +Iremos comparar o desempenho de ambas as soluções para uma mesma entrada de tamanho $n$, para valores de $n$ cada vez maiores. Para tal utilizaremos o seguinte equipamento: + +```shell +System: + Host: manjaro Kernel: 5.10.70-1-MANJARO x86_64 bits: 64 + Desktop: GNOME 40.5 Distro: Manjaro Linux +Machine: + Type: Portable System: Dell product: Inspiron 5548 v: A10 + serial: + Mobo: Dell model: 0YDTG3 v: A02 serial: + UEFI-[Legacy]: Dell v: A10 date: 05/28/2019 +Battery: + ID-1: BAT1 charge: 39.3 Wh (100.0%) condition: 39.3/42.2 Wh (93.3%) +CPU: + Info: Dual Core Intel Core i7-5500U [MT MCP] speed: 2395 MHz + min/max: 1500/3000 MHz +Graphics: + Device-1: Intel HD Graphics 5500 driver: i915 v: kernel + Device-2: AMD Topaz XT [Radeon R7 M260/M265 / M340/M360 / M440/M445 + / 530/535 / 620/625 Mobile] + driver: amdgpu v: kernel + Device-3: Sunplus Innovation Integrated_Webcam_HD type: USB + driver: uvcvideo + Display: x11 server: X.Org 1.20.13 driver: + loaded: amdgpu,ati,modesetting resolution: 1920x1080~60Hz + OpenGL: renderer: Mesa Intel HD Graphics 5500 (BDW GT2) + v: 4.6 Mesa 21.2.3 +Network: + Device-1: Realtek RTL810xE PCI Express Fast Ethernet driver: r8169 + Device-2: Intel Wireless 7265 driver: iwlwifi + Device-3: Intel Bluetooth wireless interface type: USB + driver: btusb +Drives: + Local Storage: total: 931.51 GiB used: 916.26 GiB (98.4%) +Info: + Processes: 288 Uptime: 1h 59m Memory: 15.55 GiB + used: 3.66 GiB (23.6%) Shell: fish inxi: 3.3.08 +``` + +Os valores a serem avaliados[^6] serão sorteados fazendo uso do programa `gerador`[^7] e o índice a ser buscado será sorteado fazendo uso uso do comando `random`, função do shell `fish` na versão `3.3.1`. Este é um exemplo do cabeçalho de um arquivo de texto gerado desta forma: + +```shell +> head -4 tests/1.txt +10000 4430 +1747153665 +1888832918 +1550537203 +> +``` + +O primeiro valor (`10000`) descreve o tamanho da entrada, o segundo (`4430`) o índice buscado, os valores restantes são uma amostra daqueles a serem avaliados. tais aquivos serão providos enquanto argumentos para os programas de teste[^8][^9], e o desempenho destes será avaliado fazendo uso do comando `time`, também função do shell `fish`, da seguinte maneira: + +```shell +> time mergeSelect/automatic_test.out < tests/1.txt +O 4430º elemento de menor valor: 934763211 + +________________________________________________________ +Executed in 4,55 millis fish external + usr time 4,50 millis 257,00 micros 4,25 millis + sys time 0,07 millis 67,00 micros 0,00 millis + +> +``` + +O tempo descrito em `Executed in` será aquele que iremos avaliar. + +### Resultado + +Os seguintes gráfico e tabela relatam o resultado da experimentação: + + + +| Tamanho da entrada | Tempo de execução — *mergeSelect* | Tempo de execução — *quickSelect* | +| ------------------ | --------------------------------- | --------------------------------- | +| 1 | 4.55 | 4.43 | +| 10 | 34.05 | 18.6 | +| 20 | 67.28 | 26.98 | +| 30 | 102.95 | 45.49 | +| 40 | 136.44 | 57.31 | +| 50 | 170.6 | 73.77 | +| 60 | 203.99 | 84.78 | +| 70 | 239.94 | 93.67 | +| 80 | 281.89 | 103.51 | +| 90 | 316.28 | 125.8 | +| 100 | 343.58 | 126.54 | + +> Tamanho da entrada dado em dezena de milhares (10^4^) e tempo de execução em milissegundos (ms). + +## Conclusão + +A análise preliminar dos algoritmos de busca elaborou quantitativamente minha expectativa para crescimentos significativamente distintos do tempo de execução em função do tamanho da entrada, a qual foi seguidamente demonstrada em um experimento empírico. É possível afirmar que dentre os algoritmos apresentados o *quickSelect* é aquele mais eficiente na solução do problema apresentado dada uma entrada com valores aleatórios e com pouca ou nenhuma repetição, situação esta que corresponde de maneira mais próxima a seu caso médio. Podemos atribuir esta maior eficiência ao seu procedimento de particionamento que apenas parcialmente ordena o arranjo de valores, ainda que suficientemente para encontrar o $i$-ésimo maior valor, reduzindo desta forma o número de comparações feitas. + +Por fim, fica demonstrada a importância e utilidade de métodos de análise de algoritmos para verificar a correção e desempenho destes à partir da avaliação de seu código, em particular na identificação de padrões de recorrência como a *Divisão e Conquista* e na aplicação do *Teorema Mestre* tal qual foi aqui realizado. + +[^1]: nUSP: 12543033; Turma 04. + +[^2]: **Merge sort**. Disponível em: . Acesso em: 8 nov. 2021. + +[^3]: RIBEIRO, M. **Introdução à Análise de Algoritmos**. Disponível em: https://github.com/marciomr/apostila-iaa/blob/master/apostila-iaa.pdf. Acesso em: 13 out. 2021. + +[^4]: BARRETO, G. **mergeSelect/manual_test.c**. Disponível em: https://git.disroot.org/SI/semestre_2/src/branch/master/Introdu%c3%a7%c3%a3o%20%c3%a0%20An%c3%a1lise%20de%20Algoritmos/EP%201/mergeSelect/manual_test.c. Acesso em: 13 out. 2021 + +[^5]: BARRETO, G. **quickSelect/manual_test.c**. Disponível em: https://git.disroot.org/SI/semestre_2/src/branch/master/Introdu%c3%a7%c3%a3o%20%c3%a0%20An%c3%a1lise%20de%20Algoritmos/EP%201/quickSelect/manual_test.c. Acesso em 13 out. 2021 + +[^6]: BARRETO, G. **tests**. Disponível em: https://git.disroot.org/SI/semestre_2/src/branch/master/Introdu%c3%a7%c3%a3o%20%c3%a0%20An%c3%a1lise%20de%20Algoritmos/EP%201/tests. Acesso em: 13 nov. 2021 + +[^7]: RIBEIRO, M. **gerador.c**. Disponível em: https://github.com/marciomr/IAA/blob/main/gerador.c. Acesso em: 12 nov. 2021 + +[^8]: BARRETO, G. **mergeSelect/automatic_test.c**. Disponível em: https://git.disroot.org/SI/semestre_2/src/branch/master/Introdu%c3%a7%c3%a3o%20%c3%a0%20An%c3%a1lise%20de%20Algoritmos/EP%201/mergeSelect/automatic_test.c. Acesso em 13 nov. 2021 + +[^9]: BARRETO, G. **quickSelect/automatic_test.c**. Disponível em: https://git.disroot.org/SI/semestre_2/src/branch/master/Introdu%c3%a7%c3%a3o%20%c3%a0%20An%c3%a1lise%20de%20Algoritmos/EP%201/quickSelect/automatic_test.c. Acesso em 13 nov. 2021 \ No newline at end of file diff --git a/Introdução à Análise de Algoritmos/EP 1/help-dummy.o b/Introdução à Análise de Algoritmos/EP 1/help-dummy.o new file mode 100644 index 0000000..d138dc9 Binary files /dev/null and b/Introdução à Análise de Algoritmos/EP 1/help-dummy.o differ diff --git a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.h b/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.h index a9eaa7b..6a8e760 100644 --- a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.h +++ b/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.h @@ -1,5 +1,5 @@ #define array int* -#include "./merge_select.c" +#include "./merge_sort.c" void merge (array A, int pivot, int size); void mergeSort (array A, int size); diff --git a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select_aut.c b/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select_aut.c deleted file mode 100644 index 733b800..0000000 --- a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select_aut.c +++ /dev/null @@ -1,44 +0,0 @@ -#include -#include -#define array int* - -void merge (array A, int pivot, int size) { - int i, k, j = pivot, tmp[size]; - - for (i = k = 0; k < size; k++) - tmp[k] = ((A[i] <= A[j] && i < pivot) || j == size) ? A[i++] : A[j++]; - for (k = 0; k < size; k++) - A[k] = tmp[k]; -} - -void mergeSort (array A, int size) { - int pivot; - - if (size == 1) - return; - pivot = (size - 1) / 2; - mergeSort(A, ++pivot); - mergeSort(A + pivot, size - pivot); - merge(A, pivot, size); -} - -int main () { - int i = 0, size, index; - array A; - - scanf(" %d %d", &size, &index); - if (index <= 1 || index >= size) { - printf("Índice invalido: %d não se encontra desde 1 a %d.\n", index, size); - return 1; - } - A = malloc(size * sizeof(int)); - while (i < size && scanf(" %d", A + i)) - i++; - if (i < size) { - printf("Lista mal formatada: apenas %d valores foram encontrados.\n", i); - return 1; - } - mergeSort(A, size); - printf("O %dº elemento de menor valor: %d\n", index, A[index - 1]); - return 0; -} diff --git a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.c b/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_sort.c similarity index 72% rename from Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.c rename to Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_sort.c index 51ca3a9..f03508a 100644 --- a/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_select.c +++ b/Introdução à Análise de Algoritmos/EP 1/mergeSelect/merge_sort.c @@ -4,7 +4,8 @@ void merge (array A, int pivot, int size) { int i, k, j = pivot, tmp[size]; for (i = k = 0; k < size; k++) - tmp[k] = ((A[i] <= A[j] && i < pivot) || j == size) ? A[i++] : A[j++]; + tmp[k] = ((A[i] <= A[j] && i < pivot) || j == size) ? + A[i++] : A[j++]; for (k = 0; k < size; k++) A[k] = tmp[k]; } @@ -14,8 +15,8 @@ void mergeSort (array A, int size) { if (size <= 1) return; - pivot = (size - 1) / 2; - mergeSort(A, ++pivot); + pivot = size / 2; + mergeSort(A, pivot); mergeSort(A + pivot, size - pivot); merge(A, pivot, size); }