Browse Source

Update 'lista5.md'

capella 7 years ago
parent
commit
0b937b365b
1 changed files with 24 additions and 3 deletions
  1. 24 3
      lista5.md

+ 24 - 3
lista5.md

@@ -38,8 +38,27 @@ $$\frac{n!}{2^n} \leq 2^h$$
 $$h \geq lg \space (n!) - n$$
 $$h \geq lg \space (n!) - n \geq  n \cdot lg \space (n) - n = \Omega(n \cdot lg \space (n))$$
 
+###### 3. (CLRS 8.2-4) Descreva um algoritmo que, dados n inteiros no intervalo de 1 a k, preprocesse sua entrada e então responda em O(1) qualquer consulta sobre quantos dos n inteiros dados caem em um intervalo [a..b]. O preprocessamento efetuado pelo seu algoritmo deve consumir tempo O(n + k).
 
-###### 3. (CLRS 8.4-1) Simule a execução do BUCKETSORT com o vetor $A[1..10] = \<0.79, 0.13, 0.16, 0.64, 0.39, 0.20, 0.89, 0.53, 0.71, 0.42\>$.
+$A$ é o vetor com os $n$ elementos.
+
+```
+Processa(A, n k)
+    B[1..k] <- 0
+    para i igual a 1 até n
+        B[A[n]] <- B[A[n]] + 1
+    para i igual a 2 até k
+        B[i] <- B[i] + B[i-1]
+```
+
+A linha 2 e 3 consome tempo proporcional a n e a 4 e 5 proporcional a k, portanto o tempo de execução será $O(kn)$.
+
+```
+Descobre(a, b, B)
+    return B[b]-B[a]
+```
+
+###### 4. (CLRS 8.4-1) Simule a execução do BUCKETSORT com o vetor $A[1..10] = \<0.79, 0.13, 0.16, 0.64, 0.39, 0.20, 0.89, 0.53, 0.71, 0.42\>$.
 
 ```
 B[1..10] = [[], [], [], [], [], [], [], [], [], []]
@@ -61,19 +80,21 @@ Concatenamos as listas
 B[1..10] = [0.13, 0.16, 0.20, 0.39, 0.42, 0.53, 0.64, 0.71, 0.79, 0.89]
 
 ```
-###### 4. (CLRS 8.4-2) Qual é o consumo de tempo de pior caso para o BUCKETSORT? Que simples ajuste do algoritmo melhora o seu pior caso para O(n lg n) e mantém o seu consumo esperado de tempo linear.
+###### 5. (CLRS 8.4-2) Qual é o consumo de tempo de pior caso para o BUCKETSORT? Que simples ajuste do algoritmo melhora o seu pior caso para O(n lg n) e mantém o seu consumo esperado de tempo linear.
 
 O pior caso no BUCKETSORT é quando todos os elementos da lista cairem na mesma sub-lista do vetor B. Nesse caso o nosso algorítimo vai levar tempo proporcional ao método de ordenação que utilizamos para ordenar essas sub-listas. No livro, ele escolhe o InsertionSort que posui pior caso $nˆ2$, se trocarmos por qualquer algorítmo de tempo máximo $O(n lg \space n)$, teremos o pior caso como $O(n lg \space n)$. Vamos averiguar se preserva o caso médio, $n\_i$ será o número de elementos médio no sub vetor
 
 $$E[T(n)] = E[\Theta (n) + \sum\_{i = 1}^{n} O(n\_i lg \space n\_i)]$$
 $$E[T(n)] = \Theta (n) + \sum\_{i = 1}^{n} O(E[n\_i lg \space n\_i]) = \Theta (n) + O(n lg \space n)$$
 
-###### (CLRS 28.2-5) Quão rápido você consegue multiplicar uma matriz kn × n por uma n × kn usando o algoritmo de Strassen como uma subrotina? Responda a mesma questão com a ordem das matrizes de entrada invertida.
+###### 6. (CLRS 28.2-5) Quão rápido você consegue multiplicar uma matriz kn × n por uma n × kn usando o algoritmo de Strassen como uma subrotina? Responda a mesma questão com a ordem das matrizes de entrada invertida.
 
 Vamos supor que quermos multilicar $A\_{kn\*n}$ por $B\_{n\*Kn}$, note que vamos obter uma matriz $C$ de dimenções $kn\*kn$. Vamos dividir $A$ em $k$ matrizes de dimenões $n\*n$, sendo assim teremos $A=\begin{bmatrix} A_1 \\\ A_2 \\\ ... \\\ A_n \end{bmatrix}$. O mesmo Vale para $B=\begin{bmatrix} B_1 & B_2 & ... & B_n \end{bmatrix}$ Veja que $C = \begin{bmatrix} A_1 \cdot B_1 & A_1 \cdot B_2 & ... & A_1 \cdot B_n \\\ A_2 \cdot B_1 & A_2 \cdot B_2 & ... & A_2 \cdot B_n \\\ ... & & & ... \\\ A_n \cdot B_1 & A_n \cdot B_2 & ... & A_n \cdot B_n \end{bmatrix} $. Fazendo dessa maneiro o tempo esperado da multiplicação será $\Theta(k^2 \cdot n^{lg \space 7})$, pois termos $k^2$ multiplicações de matrizes de dimensões $n\*n$ e o algoritmo de Strassen leva tempo proporcionar a $\Theta(n^{lg \space 7})$.
 
 Invertendo a ordem e fazendo $B \cdot A$, vamos obter um $C$ de dimensões $n\*n$. Veja que para esse caso $D = B \cdot A$ e $C = D_1 +D_2 + ... +D_n$, portanto para esse caso o tempo será $\Theta(k \cdot n^{lg \space 7})$.
 
+###### 7. No Select-BFPRT, os elementos do vetor são divididos em grupos de 5. O algoritmo continua linear se dividirmos os elementos em grupos de 7? E em grupos de 3? Justifique sua resposta.
+