Gabriel Gomes de Oliveira Costa RA : 11201921471

1 - Para resolvermos nosso problema de maximização podemos adotar uma estratégia

gulosa ordenando os vetores A e B em ordem decrescente, assim, podemos definir o
algoritmo como :

maxFuncaoPremio(A, B) {
1 ordenaDecrescente(A) // θ(nlogn)
2 ordenaDecrescente(B) // θ(nlogn)
3 return funcaoPremio(A, B)// θ(1)
}

Temos que o tempo de execução da função é θ(n log n) cumprindo o que foi
proposto no enunciado. Agora iremos provar sua corretude, claramente para isso devemos
provar que para quaisquer índices i < j, vale que :

A[i]^B[i] · A[j]^B[j] ≥ A[i]^B[j] · A[j]^B[i]

2 - Para resolver esse problema podemos adotar uma estratégia gulosa que ordena de
forma crescente as tarefas pelo tempo de processamento, assim podemos ter um algoritmo
como :

determinaMenorTempoMedio(S, n) {
1 F = {} // vetor vazio que conterá os valores de fi θ(1)
2 tempoMedio = 0 // θ(1)
3 tempoTotal = 0 // θ(1)
4 ordenaCrescentePorTempoProcessamento(S) // θ(nlogn)
5 para i = 1 até n : // θ(n)
6 F.adiciona(S[i] + tempoTotal) // θ(n)
7 tempoMedio = somaValoresdoVetor(F)/n // θ(1)
8 return tempoMedio // θ(1)
}

Analisando o algoritmo podemos verificar que seu tempo de execução é θ(nlogn).

Assim, dado o algoritmo podemos provar que a estratégia gulosos encontrada é ótima, para
isso iremos usar a prova por contradição.
Desta maneira, podemos supor que a nossa solução sigma encontrada não é ótima
e assim existe uma solução sigma* que é ótima. Primeiramente, iremos renomear as tarefas
de acordo com o sigma, isto é, p1 > p2 > p3... pn.
Logo, como sigma é diferente de sigma* podemos dizer que existe uma inversão em
sigma*, i.e, elementos i,j adjacentes em que j < i e esses elementos no sigma* i vem antes
do j. Como, j < i temos que pi > pj.
Agora, invertendo os valores i e j em sigma* seguindo o critério guloso que definimos,
podemos ver que :

** Chamamos a somatória dos valores que vão até (i, j) de K e a somatória dos valores após
(i, j) de L.
 Vimos então que conseguimos diminuir o delta realizando a troca seguindo o nosso
critério guloso, o que é um absurdo pois sigma* deveria ser uma ótima solução. Logo,
conseguimos provar que a nossa solução é correta.
3-

Realizando uma adaptação do algoritmos de busca por profundidade (DFS), conseguimos

criar um algoritmo que encontra o maior caminho possível.
4-

c-
Para realizar a solução do problema tomamos o algoritmo que resolve o problema
da mochila binária como base e efetuamos uma modificação que nos permita adicionar o
mesmo item mais de uma vez, a grande “sacada” está na linha 10 :

Note que a expressão piso(x / wj) multiplicando o vj considera a adição do mesmo

item na bolsa respeitando o peso da bolsa e adição do mod(x / wj) como a coluna da linha
anterior a ser somada também garante a integridade. Como fizemos uma adaptação do
algoritmo que resolve a mochila binária (KP) e essa alteração não modifica o tempo de
execução do algoritmo podemos afirmar que o nosso algoritmo roda em θ(nW), ou seja,
roda em tempo pseudo-polinomial.
d-
 Para criar esse algoritmo foi realizado uma adaptação do algoritmo mochila binária
(KP) considerando o que encontramos no exercício C (IKP), a ideia foi dividir o problema em
2 casos ( linhas 11 até 16 ) :

Caso 1 : o piso(x / wj) é maior que o limite bj

Se isso acontecer iremos multiplicar bj pelo valor do piso(x / wj) e a coluna da linha anterior
a ser somada irá ser X - (wj - bj), quando o limite é igual a 1 esse caso se iguala ao
algoritmo da mochila binária (KP).

Caso 2 : o piso(x / wj) é menor que o limite bj

Quando isso ocorre temos um problema semelhante ao que vimos no problema da mochila
inteira (IKP), assim basta executarmos o que fizemos no exercício C, tomando a coluna da
linha anterior a ser somado como mod(x / wj) e multiplicar vj por piso(x / wj).

Além disso, como falado no exercício anterior, fizemos uma adaptação do algoritmo que
resolve a mochila binária (KP) e essa alteração não modifica o tempo de execução do
algoritmo, portanto, BKP roda em tempo θ(nW), i.e, em tempo pseudo-polinomial.