Capítulo 12 - Análise da eficiência de algoritmos

Transcrição

1 Capítulo 1 - Aálise da eficiêcia de algoritmos Neste capítulo efectuaremos uma itrodução à aálise de eficiêcia de algoritmos, tópico importate da ciêcia da computação, ilustrado-a através de algus exemplos. Iremos cosiderar que os algoritmos a aalisar se ecotram implemetados a liguagem de programação Mathematica. Como veremos, a aálise do custo de algoritmos recursivos coduz-os em geral a relações de recorrêcia, ao passo que somatórios aparecem muitas vezes ligados à caracterização do custo de ciclos. Algoritmos recursivos, que se baseiam em dividir um problema um certo úmero (fixo) de subproblemas, coduzem-os ormalmete a certo tipo relações de recorrêcia ão lieares, ão aalisadas explicitamete o capítulo 9, pelo que também aproveitaremos este capítulo para itroduzir um método que em geral permite determiar a ordem de gradeza da solução de tais relações de recorrêcia. Por outro lado, embora algoritmos recursivos sejam ormalmete a solução computacioal mais simples e elegate para certo tipo de problemas, eles são em regra um pouco meos eficietes que os correspodetes algoritmos de caráter iterativo, e em certos casos (que caracterizaremos iformalmete) ão têm mesmo qualquer iteresse prático, devido à sua ieficiêcia. Fialmete, como já referimos, embora o tempo de execução ão seja o úico aspecto relevate a aálise de um algoritmo, uma vez que este cosome outros recursos computacioais (como memória) que também têm de estar dispoíveis, iremos cocetrar a ossa aálise apeas o tempo de execução (ou, mais precisamete, uma medida que traduza de algum modo tal tempo de execução dos algoritmos). Secção 1: Aálise empírica. Cosidere-se que temos um certo problema que queremos resolver computacioalmete, e que dispomos de dois (ou mais) programas que resolvem o problema em causa e queremos escolher o melhor (o setido de o mais eficiete com meor tempo/custo de execução) de etre eles. Uma primeira coisa que podemos fazer é proceder a uma (chamada) aálise empírica: pôr os dois programas a correr e ver qual demora meos tempo. Se um demorar 1 segudo e o outro 10 segudos, tudo idica que o primeiro é melhor. E, a prática, muitas vezes limitamo-os a uma aálise empírica, deste tipo. No etato, se em casos como o aterior, esta aálise empírica é um idicador que o programa que demora meos tempo é capaz de ser o melhor, ela pode ser egaadora, e tem de ser feita com cuidado: Se um demorar 1h e o outro 1h15m, será que aida poderemos estar tão certos de que um é melhor que o outro 1? 1 Para além dos aspectos a seguir mecioados, refira-se aida que poderá acotecer que a ideia que está por detrás de um programa seja até melhor do que a que está por detrás do outro, mas que essa ideia teha sido um caso implemetada de forma optimizada para um certo sistema computacioal, ao passo que o outro caso pode estar mal implemetada (ão o setido de ão estar correcta i.e. de ão resolver o problema, mas sim o setido de estar implemetada de forma claramete pouco eficiete). Por exemplo, as fuções predefiidas do sistema Mathematica foram costruídas de forma totalmete optimizada, de modo a tirar o máximo partido das características desse sistema. 419

2 Se os programas em causa, em vez de demorarem segudos, demorarem horas ou dias a correr, será que esta aálise aida é uma boa solução? Pelo meos do poto de vista teórico, um programa pode demorar, para uma istâcia de dimesão (mesmo para um valor de razoável) 10 vezes meos tempo do que outro, mas para istâcias maiores (ou muito maiores) pode ser muito, muito pior. Como se ilustrou o capítulo aterior, se um programa executar p.ex operações e outro executar 3 operações, e se cada operação demorar (em média) um ao-segudo a ser executada, etão para =100 o primeiro demora 10 vezes mais tempo que o segudo (0,01 segudos vs 0,001 segudos), para =1000 demoram o mesmo tempo (1 segudo), mas para = , o primeiro demora 77,8 horas ao passo que o segudo demorará 31,71 aos! Até que poto ão poderemos estar a executar os programas para uma istâcia do problema que correspoda ao caso mais favorável para um dos programas e ao mais desfavorável para o outro? Pode ser que um dos programas se comporte melhor para iput s de pequea dimesão e o outro para iput s de maior dimesão (e podemos querer apllicar o programa a um cojuto de casos de pequea ou de grade dimesão, devedo etão a escolha ser feita em fução disso). Devemos portato, em geral, mesmo quado fazemos uma aálise empírica, proceder ão a um teste, mas sim a uma bateria de testes que permita testar os programas para diversos tipos de iput s pequeos e/ou grades (em fução do caso em questão) e que cubram as diversas situações possíveis (melhor situação para um e para outro programa, pior situação, situação típica ). Mas isso obriga a que se aalise os algoritmos em causa, estudado como o comportameto dos programas é afectado por certas características dos iput s relevates. Assim, embora tal aálise empírica seja relevate, e ão deva ser desprezada, o que em geral se procura fazer é dispor de maeiras de medir matematicamete, de alguma forma, o tempo/custo de execução do programa, e compará-lo com o de outros programas que resolvam o mesmo problema. Isto é, como referimos o capítulo aterior, o que procuramos é traduzir tal tempo de execução como uma fução matemática do seu parâmetro e estudar como ela se comporta. Como calcular esse tempo de execução? Como observámos o capítulo aterior, uma primeira hipótese cosiste em associar a cada tipo de operação executada pelo programa um certo parâmetro que deota o tempo de execução dessa operação, cotar o úmero de vezes que são efectuadas cada uma dessas operações, e a partir daí calcular o tempo total de execução do programa como uma fução do iput, parametrizada a esses tempos (tempos que depois podemos, aturalmete, istaciar). Na próxima secção ilustraremos este tipo de aálise do tempo de execução de um programa, para um programa imperativo e um programa recursivo que resolvem o mesmo problema. Tempo esse cujo valor cocreto depede do sistema computacioal em que tal programa é implemetado. 40

3 Secção : Cálculo do tempo total de execução de um programa: um exemplo 3. Comecemos por cosiderar, como primeiro exemplo, o caso de um algoritmo muito simples para o cálculo do factorial de um atural. Este exemplo servirá para ilustrar todos os detalhes que podem ser cosiderados a cálculo do tempo total de execução de programas imperativos e recursivos. Supoha-se que se pretede calcular computacioalmete 4 o factorial de um úmero atural. Um algoritmo para o cálculo imperativo do factorial : É fácil costruir um algoritmo para o cálculo, imperativo, do factorial. Por exemplo, usado um, para guardar o úm ero cujo factorial se pretede calcular, e cujo valor será passado ao algoritmo (i.e. esse úmero será o valor iput do algoritmo e um será o úico parâmetro do algoritmo); res, para desigar a variável que vai guardado o res ultado calculado até ao mometo; e prox, para desigar a variável que vai cotrolado o pro g esso o cálculo; facilmete se verifica que o algoritmo a seguir (ode a variável do progresso prox idica o próx imo 5 valor a multiplicar), codificado a liguagem Mathematica, permite calcular, de forma imperativa, tal factorial (assumido, sem testar, que o iput é um atural): res = 1 ; (* cometário: res guarda o iício o valor de 0! *) prox = 1 ; While[ prox <= um, res = res * prox ; prox = prox + 1 ] Aálise do tempo de execução do algoritmo : Supoha-se, etão, que se pretede calcular o tempo de execução deste algoritmo. Uma execução deste algoritmo, evolve a execução de 5 comados/acções atómicas (atribuições ou testes). As atribuições res=1 e prox=1 são executadas uma só vez. Desigado por o valor do iput do algoritmo, que é guardado o iício em um (o v alor i icial de um, que deotaremos por 6 vi(um)), facilmete se verifica que o teste prox<=um (a chamada guarda do ciclo While) é executado/avaliado 3 Nesta secção segue-se, com ligeiras modificações (omeadamete otacioais), o texto [13]. (De facto, o exemplo aqui escolhido é diferete do exemplo itrodutório cosiderado em [13], mas o tipo de aálise é aáloga.) 4 Várias liguages de programação, como p.ex. o Mathematica, já dispoibilizam fuções predefiidas que permitem efectuar directamete o cálculo do factorial, aturalmete mais eficietes do que aquelas que iremos referir em seguida. Mas o objectivo aqui é apeas o usarmos este exemplo para ilustrar como se calcula os tempos associados a programas imperativos e recursivos. 5 Pelo que por vezes se diz que a variável do progresso está adiatada. Refira-se aida que o ome prox, usado este exemplo para a variável do progresso, foi escolhido de forma a ser memóico de próximo (salietado assim que o progresso estava adiatado ). Aalogamete, o ome res foi escolhido para sugerir (variável do) resultado. No etato, em sempre temos estas preocupações metodológicas, escolhedo ormalmete omes mais curtos para as variáveis do programa (p.ex. i e j são omes usualmete escolhidos para a variável do progresso). 6 No caso do algoritmo em questão o valor guardado em um ão é alterado durate a execução do algoritmo (um ão é alvo de qualquer atribuição). No etato, à partida, ada impede que um programa se altere uma variável, que guarda o iício o iput do programa, pelo que covém dispomos de otações que os permitam falar desse valor. 41

4 +1 vezes (uma vez que o teste prox<=um é avaliado com prox=1,...,um+1, e o valor guardado em um ão é alterado). Fialmete, cada uma das atribuições res=res*prox e prox=prox+1 é executada uma vez por cada execução do passo do ciclo While; como este é executado com prog=1,...,um (e o valor guardado em um ão é alterado), temos que cada uma dessas atribuições é executada vezes. Se assumirmos que o tempo de execução de uma atribuição ou teste ão depede dos valores guardados as variáveis evolvidas (pelo que cada execução dessa atribuição ou teste demorará o mesmo tempo), etão é fácil de calcular o tempo total de execução do algoritmo sabedo o úmero de vezes que é executada cada atribuição e teste. O quadro seguite resume essa iformação, desigado por t 1,..., t 5 os tempos de execução das 5 operações em causa e cosiderado = vi(um): operação tempo de execução º de vezes res=1 t 1 1 prox=1 t 1 prox<=um t 3 +1 res=res*prox t 4 prox=prox+1 t 5 Desigado por T algoritmo () o tempo de execução do algoritmo (com iput ), tem-se etão que T algoritmo () = t 1 + t + (+1) t 3 + t t 5 = (t 3 +t 4 +t 5 ) + t 1 + t + t 3 isto é, T algoritmo () é da forma T algoritmo () = k 1 + k com k 1 e k costates, e k 1 0, pelo que T algoritmo () = Θ(). Em vez de T algoritmo (), podemos também usar T algoritmo (um ) como forma de salietar que estamos a descrever o tempo que demora a executar o algoritmo quado o seu (úico) parâmetro um assume o iício o valor. A expressão T algoritmo (um ) = k 1 + k salieta que o tempo do algoritmo só depede do valor iicialmete atribuído ao parâmetro um, sedo uma fução liear desse valor. É possível proceder a uma aálise mais fia dos tempos acima, em que se detalha os tempos evolvidos o cálculo das diferetes operações 7. Tal é feito a seguir. Observação 1 (cálculo dos tempos evolvidos a avaliação de expressões e atribuições) : Seguem-se algumas observações sobre os tempos evolvidos a avaliação de expressões e atribuições, que são relevates quado se pretede fazer uma aálise mais detalhada desses tempos. 7 Este tipo de aálise mais detalhada ão se justificaria o âmbito deste exemplo, tão simples, sedo aqui efectuada essecialmete apeas para ilustrar como é que ela pode feita. 4

5 Começado pela avaliação de expressões, cosidere-se, por exemplo, a expressão res*prog. A sua avaliação exige o acesso a duas variáveis e à multiplicação dos seus valores. Se assumirmos que o tempo associado à localização de uma v ariável ão depede de qual é essa variável (sedo, portato, uma costate que desigaremos a seguir de t v ) e se assumirmos (para simplificar) que o tempo que demora a multiplicar dois valores ão depede da ordem de gradeza dessas valores, etão podemos dizer que o tempo que demora a avaliar res*prog é dado por t v +t * +t v (com t * o tempo da multiplicação). Mais geralmete, podemos dizer que o tempo de avaliação de uma expressão ão atómica o(exp1,...,exp) é igual à soma dos tempos ecessários à determiação dos valores e1,...,e das expressões argumeto exp1,.., exp, mais o tempo ecessário ao cálculo do valor o(e1,...,e), assumido-se em geral (para as expressões aritméticas e booleaas) que o tempo associado ao cálculo do valor o(e1,...,e) é idepedete dos valores e1,...,e em causa, pelo que o podemos desigar por uma costate (depedete apeas da operação em causa) t o. No que respeita às atribuições, o tempo associado à execução de uma atribuição var=exp é igual ao tempo T(exp) de determiação do resultado da expressão exp mais o tempo correspodete à associação desse valor à variável var. Se assumirmos que o tempo correspodete à associação do valor da expressão exp à variável var, em questão, ão depede em de qual é essa variável, em de qual é o valor da expressão exp, podemos desigar esse tempo por uma costate t =, tedo-se T(var=exp) = t = + T(exp). À luz das cosiderações ateriores, é fácil verificar que, o caso em questão, se tem 8 : t 1 = T(res=1) = t = t = T(prox=1) = t = (= t 1 ) t 3 = T(prox<=um) = 9 t v + t <= + t v t 4 = T(res=res*prox) = t = + t v + t * + t v t 5 = T(prox=prox+1) = t = + t v + t + e T algoritmo () = T algoritmo (um ) = (t 3 +t 4 +t 5 ) + t 1 + t + t 3 = (5t v + t = + t * + t <= ) + t v + t = + t <= Fuções/programas Mathematica e sua ivocação: Se quisermos codificar o algoritmo atrás como um programa/fução da liguagem Mathematica, que recebe o iput através do parâmetro um, e retora o resultado calculado 10, somos coduzidos ao seguite programa 11, a que chamaremos de factimp (abreviatura de fac torial imp erativo ): 8 Assume-se a seguir que, durate a execução do programa, a avaliação das expressões, a idetificação das costates que elas ocorrem ão evolve qualquer tempo. Mesmo que isso possa ão ser completamete verdade, tal tempo será certamete a prática desprezável. Mais aida, como se pode assumir que ele é idepedete do valor da costate em causa (sedo portato um tempo costate que poderíamos deotar por t c ), a sua evetual cosideração ão afectaria o essecial do que se segue (acrescetado apeas mais umas costates às expressões a que chegaremos). 9 Está-se aqui a cosiderar que um é uma variável. Embora essa seja a situação usual as liguages de programação, o caso da liguagem Mathematica, um fucioará como um parâmetro da fução (ver a seguir), que é substituído pelo valor do argumeto, aquado de uma ivocação, e ão como uma varável (local) o qual é guardada o valor do argumeto. 10 No Mathematica é retorado o valor da última expressão avaliada, pelo que uma forma de retorar o resultado pretedido cosiste em o fial (como última istrução) madar avaliar a variável res que guarda esse resultado. 11 Ode as variáveis prox e res são declaradas como variáveis locais ao corpo da fução, através da costrução Module. 43

6 factimp = Fuctio[um, Module[{res,prox}, (* cometário: segue-se o corpo da fução *) res = 1 ; prox = 1 ; While[ prox <= um, res = res * prox ; prox = prox + 1 ] ; res ]]; Podemos agora ser mais precisos e calcular mesmo o tempo evolvido a obteção do valor do factorial em causa, através da ivocação desta fução/programa 1 Mathematica. Sedo 13 f = Fuctio[{par 1,...,par k }, corpo] uma fução Mathematica de k parâmetros 14, o tempo T(f[exp 1,...,exp k ]), associado a uma ivocação f[exp 1,...,exp k ] de f (ode exp 1,...,exp k desigam as k expressões argumeto dessa ivocação), pode ser obtido como se segue: T(f[exp 1,...,exp k ]) = T(exp 1 ) T(exp k ) + c iv + T corpo(f) (par 1 vi(exp 1 ),...,par k vi(exp k )) ode: T(exp j ) desiga o tempo associado à determiação do valor da expressão exp j (para j=1,...,k); vi(exp j ) desiga esse valor, isto é, mais precisamete, o valor que a expressão exp j deota aquado (o iício) da ivocação (podemos ler vi(exp j ) como o v alor i icial, ou o v alor aquado da i vocação, da expressão exp j ) 15 ; c iv (memóico de c usto da iv ocação) é uma costate 16 que deota a soma dos seguites tempos: localização da fução f, atribuição aos parâmetros dos valores das correspodetes expressões 1 O que se segue será particularmete relevate para a aálise do tempo do cáculo recursivo do factorial, a discutir a seguir. 13 As chavetas em toro da sequêcia de parâmetros ão são ecessárias se só existir um parâmetro (ver apêdice ). 14 Ou, caso existam variáveis locais: f = Fuctio[{par 1,...,par k },Module[{sequêcia das variáveis locais}, corpo]]. 15 Como um programa pode recorrer e alterar variáveis globais (herdadas), se alguma das evetuais variáveis ocorredo a expressão argumeto exp j for alterada durate a execução do corpo da fução, etão o valor deotado pela expressão exp j também irá variar ao logo de tal execução, pelo que é importate especificar que vi(exp j ) deota o valor da expressão exp j aquado da ivocação. 16 Costate o setido de que ão depede das expressões argumeto, em da ordem de gradeza do seu valor. Naturalmete o tempo em causa depede de alguma forma da fução f em questão, o setido de que depede do úmero de argumetos e do corpo da fução (uma vez que há que substituir este os parâmetros pelos valores dos correspodetes argumetos), bem como depede do úmero de variáveis locais que há que criar. De qualquer forma trata-se de um tempo desprezável (quado efectuado apeas uma vez), que assumiremos costate e desigaremos por c iv, como se ele fosse idepedete da própria fução f em questão. 44

7 argumeto 17 (cujo tempo se assume que ão depede da ordem de gradeza desses valores), e criação das evetuais variáveis locais; e T corpo(f) (par 1 vi(exp 1 ),...,par k vi(exp k )) deota o tempo de execução do corpo da fução f quado o parâmetro par j (com j=1,...,k) assume o valor vi(exp j ) idicado (isto é, o valor que a correspodete expressão argumeto exp j deota aquado da ivocação) 18. Assim (de acordo com o que acabámos de ver para o caso geral), o caso em questão o tempo evolvido uma ivocação factimp[exp] é calculado como se segue: Em primeiro lugar há que determiar o valor da expressão argumeto exp, o que demora um tempo que desigámos de T(exp) (de modo a salietar que ele pode ão ser costate, depededo da expressão argumeto exp). Depois há que localizar a fução factimp, atribuir o valor da expressão argumeto (desigado de vi(exp)) ao parâmetro um, e criar as variáveis locais res e prox. Desigámos por c iv a costate correspodete à soma dos tempos associados a estas actividades (e que se assume idepedete do valor da expressão argumeto). Fialmete há que executar o corpo da fução factimp (quado o parâmetro um assume o valor vi(exp)): o caso em questão o corpo da fução é costituído pelo algoritmo aterior (cuja execução demora o tempo T algoritmo (um vi(exp)), seguido da avaliação da variável do resultado res (o que demora um tempo costate, que, seguido as otações atrás, desigaremos de t v ). Deste modo, o tempo T(factImp[exp]) de uma ivocação factimp[exp] é dado por T(factImp[exp]) = T(exp) + c iv + T corpo(factimp) (um vi(exp)) = T(exp) + c iv + T algoritmo (um vi(exp)) + t v = T(exp) + c iv + (5t v + t = + t * + t <= ) vi(exp) + (t v + t = + t <= ) + t v = k 1 vi(exp) + T(exp) + k com k 1 = 5t v + t = + t * + t <= 0 e k = c iv + 3t v + t = + t <= No caso da expressão argumeto exp ser uma variável, etão T(exp) é o tempo associado à localização do valor de, dado por t v (tempo costate que assumimos que ão depede de qual é essa variável, em de qual é o seu valor). Assim, cotiuado a desigar por o valor vi(), tem-se: T(factImp[]) = k 1 vi() + T() + k = k 1 + k + t v 17 Em vez de atribuição aos parâmetros dos valores das correspodetes expressões argumeto deveríamos dizer substituição o (em todo o) corpo da fução de cada parâmetro pelo valor da correspodete expressão argumeto, pois é isso o que é feito o Mathematica, ode os parâmetros ão fucioam como variáveis locais (ão podedo ser alvo de atribuições). No etato, como a maioria das liguages de programação (imperativas) os parâmetros são variáveis locais às quais são atribuídos os valores dos argumetos o iício da ivocação, iremos aqui, a este respeito, proceder como se o Mathematica fucioasse como as liguages de programação mais usuais (dado assim maior geeralidade ao modo como são efectuadas a seguir as cotas). 18 Poder-se-ia aida cosiderar o tempo associado ao retoro do resultado da fução (i.e., o caso do sistema Mathematica, o tempo do retoro do valor da última expressão avaliada). Iremos assumir, para simplificar, que esse tempo está icluído o que chamámos de custo da ivocação (e desigámos por c iv ). 45

8 isto é, existem costates k 1 e k 3, com k 1 0 e k 3 = k + t v, tais que T(factImp[]) = k 1 + k 3 Ou seja, T(factImp[]) cresce liearmete com (= vi()). No caso da expressão argumeto exp ser por exemplo ^ (com = vi()) etão T(factImp[^]) = k 1 vi(^) + T(^) + k com T(^) o tempo associado à localização do valor de e ao cálculo do seu quadrado, tempo costate dado por t v +t^. Assim, tem-se: T(factImp[^]) = k 1 + t v + t^ + k tempo que (aturalmete) cresce quadraticamete com (= vi()). E o tempo de uma ivocação factimp[factimp[]] será dado por T(factImp[factImp[]]) = k 1 vi(factimp[]) + T(factImp[]) + k = k 1! + k 1 + k 3 + k Cálculo recursivo do factorial : Cosidere-se agora o seguite programa recursivo para o cálculo do factorial de um iteiro positivo: factrec = Fuctio[um, If[ um == 0, (* etão o resultado é: *) 1, (* seão o resultado é: *) um * factrec[um-1] ] ]; Aálise do tempo de execução do cálculo recursivo : À luz do que observámos ateriormete, é agora fácil de calcular o tempo T(factRec[exp]) de execução de uma ivocação factrec[exp]: T(factRec[exp]) = T(exp) + c iv + T(corpo factrec (um vi(exp))) Por sua vez, o T(corpo factrec (um vi(exp))) pode ser obtido como se segue: Se vi(exp)=0, etão a execução de corpo factrec (um vi(exp)) correspode 19 a avaliar o teste um==0, que demora um tempo (costate) t v + t ==. 19 No caso da liguagem Mathematica o que devia estar aqui era correspode a avaliar o teste vi(exp)==0, que demora um tempo (costate) t == (ver ota de rodapé 17). 46

9 Se vi(exp)>0, etão a execução de corpo factrec (um vi(exp)) correspode 0 a avaliar o teste um==0 (tempo t v + t == ) e a avaliar a expressão um * factrec[um-1] o que demora o tempo t v + t * + T(factRec[um-1]) isto é t v + t * + T(um-1) + c iv + T(corpo factrec (um vi(exp)-1)) ou seja t v + t * + t v + t_ + c iv + T(corpo factrec (um vi(exp)-1)) Em resumo, desigado por o valor vi(exp) e desigado T(corpo factrec (um )) simplesmete por TC(), etão T(factRec[exp]) = T(exp) + c iv + TC() com TC() dado por uma relação de recorrêcia (como é típico o caso de programas recursivos), mais cocretamete pela relação de recorrêcia TC() = t v + t ==, se =0 TC() = t v + t * + t_ + c iv + TC(-1), se >0 Usado p.ex. o método iterativo, facilmete se chega a: TC() = t v + t == + (t v + t * + t_ + c iv ) pelo que T(factRec[exp]) = T(exp) + c iv + t v + t == + (t v + t * + t_ + c iv ) com = vi(exp). No caso da expressão argumeto exp ser uma variável, etão T(exp) é dado por t v, e portato T(factRec[]) = t v + c iv + t v + t == + (t v + t * + t_ + c iv ) isto é, existem costates d 1 e d, com d 1 0, tais que T(factRec[]) = d 1 + d pelo que também T(factRec[]) cresce liearmete com (= vi()). Observação (profudidade de recursão) : A profudidade de recursão correspode ao úmero de ivocações de uma fução recursiva que estão pedetes. Por exemplo, a ivocação de factrec[] ecessita de factrec[1] que, por sua vez, ecessita de factrec[0] (que já ão evolve qualquer ivocação recursiva). Assim, quado o cálculo de factrec[] se chega à ivocação factrec[0] estão pedetes 3 ivocações (icluido 0 No caso da liguagem Mathematica o que devia estar aqui era correspode a avaliar o teste valor(exp)==0 (tempo t == ) e a avaliar a expressão vi(exp)*factrec[vi(exp)-1] (ver ota de rodapé 17). E outras alterações, do mesmo tipo, teriam de ser feitas o que se segue, se quiséssemos fazer as cotas exactamete como as coisas se passam o Mathematica. 47

10 factrec[0]), o que sigifica uma profudidade de recursão de 3. A ivocação factrec[] implica uma profudidade de recursão de Por omissão, o sistema Mathematica defie 56 como a profudidade máxima de recursão aceite (parado o cálculo quado se chega a essa profudidade máxima, e imprimido uma mesagem apropriada, jutamete com a expressão esse mometo em avaliação). É possível, o etato, alterar este valor, modificado o valor de $RecursioLimit (por exemplo, podo-o a ifiito). Sugere-se que tal alteração da variável $RecursioLimit seja ecapsulada o âmbito de um comado Block, de modo a que ela só surta efeito durate a execução do corpo do Block (as variáveis a que são atribuídos ovos valores o Block, o fial da execução deste voltam a ter os valores que lhes estavam atribuídos ates dessa execução). Assim, avaliado, por exemplo, Block[{$RecursioLimit= }, factrec[3]] já coseguimos calcular factrec[3], apesar da profudidade de recursão requerida ser superior a 56. Coclusão comparação das versões imperativa e recursiva : No exemplo cosiderado, o comportameto assimptótico das versões imperativa e recursiva é aálogo. Tal ão sigifica, cotudo, que uma das versões ão seja mais rápida que a outra. No etato, uma comparação etre os tempos exactos de execução das duas versões, do cálculo do factorial, exigiria o cohecimeto dos valores das várias costates evolvidas as expressões matemáticas (atrás referidas) que descrevem esses tempos, e ão será objecto de aálise aqui. De qualquer forma, uma experimetação, calculado o valor do tempo de execução de factimp[] e de factrec[] para vários valores de, revela (ou, pelo meos, sugere) claramete que a versão recursiva é um pouco mais leta que a versão imperativa. Por exemplo, um computador pessoal, que hoje já estaria completamete obsoleto, obteve-se o Mathematica os seguites tempos Timig[factRec[50];] { Secod, Null} Timig[factImp[50];] { Secod, Null} e um computador pessoal muito recete obteve-se Timig[factRec[50];] { Secod, Null} Timig[factImp[50];] { Secod, Null} 1 De acordo com o texto [13], que temos seguido esta secção, a profudidade cosiderada o Mathematica é mesmo +, por razões que são aí referidas, e que ão abordaremos aqui. Compare-se a evolução o tempo de cálculo! 48

11 Qual a razão desta maior letidão da versão recursiva? Essecialmete tem a ver com o custo evolvido uma ivocação, face ao custo das operações que são executadas em cada passo do ciclo do versão imperativa, uma vez que é fácil de ver que o exemplo em causa, grosso modo, cada passo do ciclo da versão imperativa é substituído por uma ivocação da própria fução, a versão recursiva. Secção 3: Cálculo (cotagem) apeas das pricipais operações realizadas. Como se referiu o último capítulo, uma aálise da eficiêcia do tipo da aterior, em que se procura obter o tempo total de execução de uma ivocação de um programa, etrado em liha de cota com todos os tempos evolvidos essa ivocação (cotado omeadamete todas as operações executadas por um programa, e procurado associar um tempo a cada uma dessas operações), pode mostrar-se às vezes bastate complexa (embora ão se possa dizer que tal seja o caso o exemplo, muito simples, aterior). E muitas vezes ão ecessitamos de ter uma ideia tão exacta do tempo de execução do programa. O que é essecial é obter um valor que traduza de algum modo o custo da execução do programa, para cada iput. E, para esse efeito, muitas vezes basta-os cotar o úmero de vezes que são efectuadas as pricipais operações 3 que são realizadas pelo programa em causa 4, omeadamete se só quisermos ter uma ideia da ordem de gradeza do custo/tempo de execução do programa. Comecemos por ilustrar este tipo de abordagem à aálise de eficiêcia, a propósito do exemplo muito simples, do cálculo do factorial, que abordámos a secção aterior. Ates porém, efectuaremos algumas observações e estabeleceremos certas coveções otacioais a utilizar este tipo de aálise de eficiêcia, o resto deste capítulo. Observação 1 (variáveis da liguagem de programação e seu valor, e coveções otacioais) : Iformalmete, podemos dizer que uma variável de uma liguagem de programação é um ome 5 que deota um valor. De facto, uma variável de uma liguagem de programação deota uma célula de memória ode está guardada um valor (o valor que a variável idirectamete deota), valor esse que pode ser alterado durate a execução de um programa (através de comados de atribuição a essa variável). Por essa razão, em particular, tora-se por vezes coveiete distiguir estas duas perspectivas (sitáctica e semâtica), distiguido a variável (o ome), bem como as expressões costruídas à custa de variáveis, do valor que deotam. Supoha-se por exemplo que tíhamos codificado o programa factimp como se segue (de uma forma que este caso ão se acoselha, ode ele altera variáveis ão locais): 3 As operações que, em pricípio, desempeham um papel mais importate o tempo que o programa demora a ser executado. 4 E depois, se tal for desejado, podemos associar um tempo a cada uma dessas operações, obtedo uma ideia aproximada do tempo de execução do programa. 5 Mais precisamete, as liguages de programação cosidera-se em geral que uma variável é uma sequêcia (ão vazia) de letras e úmeros, começado por uma letra. No caso das liguages de programação tipadas (o que ão é o caso da liguagem Mathematica), tal sequêcia de letras e úmeros deverá aida ser declarada como sedo uma variável, ode essa declaração se idica também qual o tipo dessa variável, especificado-se assim qual o géero de valores que poderão estar guardados a(s) célula(s) de memória a associar à variável em questão. 49

12 factimp = Fuctio[um, =1; prox=1; While[prox<=um, =*prox; prox=prox+1]; ]; e que escrevíamos (iformalmete) T(factImp[]) = (5t v + t = + t * + t <= ) + (c iv + 4t v + t = + t <= ) Imediatamete poderia surgir a dúvida se o valor de o lado direito represetava o valor que tiha aquado (o iício) da ivocação factimp[] ou o valor que tiha o fim dessa ivocação factimp[] (e que é igual ao factorial do valor iicial de ) 6. Por essa razão (para evitar dúvidas como a aterior), itroduzimos a otação vi(exp) para deotar o valor que uma expressão argumeto exp deotava aquado (o iício) da ivocação de um programa 7 (cujo tempo pretedíamos calcular), e escrevemos p.ex. T(factImp[]) = (5t v + t = + t * + t <= ) vi() + (c iv + 4t v + t = + t <= ) bem como T(factImp[^]) = (5t v + t = + t * + t <= ) vi(^) + (c iv + 4t v + t = + t <= + t^ ) = (5t v + t = + t * + t <= ) + (c iv + 4t v + t = + t <= + t^ ), com = vi() e, mais geralmete, T(factImp[exp]) = T(exp) + c iv + T corpo(factimp) (um vi(exp)) Cosidere-se agora que ão pretedemos obter o tempo total de execução de uma ivocação de um programa (a seguir desigado geericamete de) prog, etrado em liha de cota com todos os tempos evolvidos essa ivocação, mas pretedemos apeas obter um valor que traduza de algum modo o custo da execução do programa, para cada iput do programa, cotado p.ex. o úmero de vezes que são efectuadas certo tipo de operações que são realizadas pelo programa em causa. Mais cocretamete, desigado por C tal fução de custo, pretede-se calcular o úmero dessas operações que são realizadas uma ivocação prog[exp], úmero que podemos desigar de C(prog[exp]). Nesse caso, ão os iteressa o custo da ivocação (que desigámos de c iv ) e podemos escrever geericamete (ode C(exp) e C corpo(prog) (um vi(exp)) têm o sigificado ituitivo esperado: p.ex. C(exp) desiga o úmero de operações desse tipo que são realizadas a avaliação da expressão exp, o que ormalmete só é relevate se exp evolver uma outra ivocação do programa em causa): C(prog[exp]) = C(exp) + C corpo(prog) (parâmetro vi(exp)) Mais aida, para este efeito ão é relevate se as expressões atómicas que compõem exp são costates ou variáveis: o que os iteressa é o seu valor. (O mesmo ão é verdade, se quisermos ser 6 Associado à execução de um programa imperativo temos uma oção de estado (da computação), caracterizado pelos valores guardados as variáveis do programa (em cada mometo dessa execução), e uma ivocação de um programa imperativo pode ser vista como uma trasição de um estado iicial para um estado fial, obtida através de sucessivas alterações do estado da computação proveietes da execução do programa ivocado. 7 Como só ecessitámos de os referir ao valor das expressões argumeto aquado (o iício) da ivocação de um programa (o estado iicial dessa ivocação), ão procurámos itroduzir otações (mais complexas) para poder deotar os valores que as variáveis (e as expressões costruídas à custa delas) podem assumir durate a (em cada mometo da) execução do programa. 430

13 muito precisos, quado se calcula T(prog[exp]): supodo p.ex. que prog recebe iteiros, etão os tempos T(prog[3]) e T(prog[]), com vi()=3, são diferetes, pois o último caso, para o cálculo de T(), há que cotar com o tempo do acesso à célula de memória associada à variável para se obter o valor 3 lá guardado). Assim, e para simplificar as otações usadas 8, iremos utilizar letras (escritas em times e itálico) para desigar valores (que à partida podem ser quaisquer), subetededo-se que quado tais letras ocorrem a expressão argumeto de uma ivocação prog[exp], tal sigifica que tais valores podem estar 9 aí a ser expressos através de uma costate, ou através de uma variável da liguagem de programação, assumidose etão, este último caso, que essa variável ão ocorre o programa prog. Esta coveção justifica-se para evitar ter de estar a cosiderar a otação vi(exp) 30, e tem em cota que esta aálise da eficiêcia estamos geericamete iteressados em caracterizar apeas (o valor do custo da execução do programa para um certo iput, idepedetemete de como este iput é expresso uma ivocação do programa, i.e. estamos iteressados em caracterizar apeas) o valor de C(prog[]) (muitas vezes abreviado por C(), deixado prog implícito) Naturalmete, se prog for um programa recursivo, para o cálculo de C(prog[]) podemos ter de calcular o valor do custo de outras ivocações de prog, com outros argumetos (como C(prog[-1])), mas esse cálculo cotiua a ser verdade que o que os iteressa é o valor do argumeto dessa ivocação, e ão ode tal valor se ecotra guardado (pois os abstraímos do tempo ecessário para o obter). Exemplo 1: cálculo do factorial (de um atural). No caso do factorial podemos supor que o custo do cálculo do factorial é essecialmete determiado pelo úmero de multiplicações realizadas. Vejamos, etão, como se obteria tal medida de custo para os dois programas idicados para o cálculo do factorial. Desige-se por NM vi () o úmero de m últiplicações realizadas pela v ersão i mperativa, tedo como iput o valor, isto é, NM vi () desiga o úmero de múltiplicações que ocorrem uma ivocação factimp[] (i.e. NM vi () pode ser visto como uma abreviatura de NM(factImp[])), ode recorde-se factimp = Fuctio[um, Module[{res,prox}, res = 1 ; prox = 1 ; While[prox<=um, res = res*prox ; prox = prox+1] ; res ]]; 8 E torar mais leves as expressões matemáticas a costruir este tipo de aálise da eficiêcia (simplificado a sua leitura). 9 Isto é, é irrelevate, para efeitos da aálise em causa, se tais valores são expressos em exp, através de uma costate, ou através de uma variável da liguagem de programação. De outra forma, supodo p.ex. que prog tem iteiros como iput, quado escrevemos prog[] tato podemos ecarar como estado a desigar uma particular costate iteira (qualquer), como podemos ecarar como uma variável da liguagem de programação (guardado iteiros) que ão ocorra em prog. 30 Pois é imediato que, debaixo da assumpção mecioada, p.ex. vi()=, vi(+)=+ e vi(+k)=+k, e, mais geralmete, o valor da expressão exp, argumeto da ivocação, ão varia com a execução do programa prog. 431

14 Ora, ocorre uma multiplicação (apeas) em cada execução do passo do ciclo While e, uma ivocação factimp[], este é executado com prog=1,...,. Assim, é imediato que 31 NM vi() = Desige-se, agora, por NM vr () o úmero de m últiplicações realizadas pela v ersão r ecursiva, tedo como iput o valor, isto é, NM vr () = NM(factRec[]), ode (recorde-se) factrec = Fuctio[um, If[um==0, 1, um * factrec[um-1]] ]; É imediato que NM vr () é dado pela relação de recorrêcia NM vr () = 0, se =0 NM vr () = 1 + NM vr (-1), se >0 e, usado p.ex. o método iterativo, facilmete se chega a NM vr () = Como era imediato, olhado para os dois programas, ambos realizam multiplicações para calcular o factorial de. Assim, equato que a aálise do tempo total (exacto) de execução, obtihamos expressões distitas para os tempos dos dois programas, esta aálise mais simples ão os coseguimos difereciar. Mas, em termos da ordem de gradeza do seu crescimeto, ambas as aálises os dizem que os dois programas são da mesma ordem de gradeza (liear em ). Aida que uma aálise iformal, se observarmos os dois programas costatamos que eles de facto têm essecialmete os mesmos custos: como o programa imperativo a iicialização das variáveis res e prox só é efectuada uma vez, para além das multiplicações, o custo do programa imperativo evolve a avaliação da guarda do ciclo (prox<=um) e o progresso o cálculo (prox=prox+1) efectuado em cada passo do ciclo; grosso modo, a isto correspode, a versão recursiva, a avaliação, em cada ivocação, do teste um==0 e do argumeto um-1 da ivocação seguite. O que tora a versão recursiva um pouco mais leta que a imperativa, são fudametalmete os outros custos associados a cada ivocação (e equato ocorre uma só ivocação a versão imperativa, a versão recursiva ocorrem +1 ivocações). Exemplo : Supremo de uma lista (de iteiros). Supoha-se agora que se pretede calcular o supremo de uma lista de iteiros distitos Para mostrar como esse úmero de comparações é obtido (em que é realizada uma multiplicação por cada execução do passo do ciclo) podemos recorrer aos somatórios e escrever NM vi () = 1 =. Tal aida ficará mais sugestivo, se utilizarmos i=1 a variável prox como variável do somatório, e escrevermos NM vi () = 1 =. prox=1 3 Os algoritmos a seguir fucioam mesmo que se permita que haja repetições a lista, mas o impor-se que ão haja repetições facilita a aálise em média da (primeira) versão recursiva que apresetaremos para o cálculo do supremo (para a aálise dos outros algoritmos tal é irrelevate). 43

15 Comecemos por uma versão imperativa. Cosiderado que o supremo de uma lista vazia de iteiros é -, facilmete se verifica que a fução Mathematica a seguir permite calcular o supremo, assumido sem o testar que o argumeto é uma lista de iteiros (para o caso poderiam ser reais). Uma versão imperativa para o cálculo do supremo: supimp = Fuctio[lista,Module[{res,prox,comp}, comp = Legth[lista]; res = -Ifiity; prox = 1; While[ prox <= comp, If[res < lista[[prox]], res = lista[[prox]]]; prox = prox + 1 ] ; res ]]; Tal como o caso aterior, vamos supor que ão pretedemos calcular o tempo exacto de execução, através da cotagem de todas as operações executadas por uma ivocação do programa e da associação a cada operação de um parâmetro deotado o tempo de execução dessa operação, mas apeas pretedemos ter uma ideia do custo de execução do programa, através da cotagem das pricipais operações realizadas. Ora, podemos cosiderar que o cálculo do supremo se baseia em comparações com os elemetos da lista argumeto, pelo que uma medida do custo da sua execução é dada pelo úmero dessas comparações que foi ecessário efectuar. Desigemos por NC vi ( úmero de c omparações da v ersão i mperativa) tal fução de custo. No etato, ao cotrário do que se passava o cálculo do factorial, em que o parâmetro da fução de custo NM vi era o valor do argumeto (da ivocação) do programa, agora o parâmetro da fução de custo NC vi ão é a lista argumeto do programa, mas sim uma medida da dimesão (complexidade) dessa lista, mais cocretamete, o seu comprimeto. Observação (fuções de custo de programas que operam sobre listas) : O procedimeto aterior ão é específico deste exemplo. Quado se aaliza a eficiêcia de um programa que opera sobre listas o seu custo/tempo ão é medido para cada lista argumeto específica, mas sim como uma fução do comprimeto da lista argumeto. (As razões deste procedimeto são simples de eteder, e já foram explicitadas a secção 1 do capítulo aterior, a propósito da ordeação de listas.) Naturalmete, só sabedo a dimesão da lista argumeto, podemos ão coseguir determiar o custo/tempo exacto da execução desse programa (pois tal poderá depeder da composição dessa lista). Quado tal acotece, o que fazemos em geral é (como se referiu a secção 1 do capítulo aterior) efectuar o cálculo do custo da execução, cosiderado: a pior situação (i.e. a situação em que a lista iput, de dimesão, tem as piores caraterísticas para o programa em causa), a melhor situação e em média (ão 433

16 assumido ada sobre o iput em causa, i.e. cosiderado que ele pode ser uma qualquer lista de dimesão, e supodo que todas as listas de dimesão são igualmete prováveis). Embora, como se acabou de referir, possa acotecer que, só sabedo a a dimesão da lista argumeto, ão seja possível determiar o valor exacto da fução de custo do programa (obrigado a uma evetual aálise a pior situação, em média e a melhor situação), ão é isso o que se verifica o caso vertete, em que se pretede que o custo da execução do programa seja traduzido simplesmete pelo úmero de comparações com elemetos da lista realizadas, uma vez que é imediato verificar que este úmero ão depede da composição da lista argumeto, mas apeas da sua dimesão. Comece-se, etão, por precisar o que se pretede: dado um qualquer atural, NC vi () é o úmero de comparação com elemetos da lista w que ocorre uma ivocação supimp[w] (úmero que podemos desigar por NC(supImp[w])), quado se assume que a lista argumeto w é uma qualquer lista de iteiros distitos. Ora, o cálculo NC vi () é muito simples, sedo perfeitamete aálogo ao cálculo de NM vi () efectuado o exemplo aterior, uma vez que é realizada uma comparação com um elemeto da lista argumeto da ivocação, por cada execução do passo do ciclo: Legth[w] NC vi () = 1 = 1 = prox=1 prox=1 Observação 3 : Supoha-se, agora, que em vez de se querer cotar apeas o úmero de comparações com elemetos da lista argumeto, se pretedia cotar o úmero total de operações realizadas (mais precisamete, apeas o úmero total de atribuições e testes realizados) durate uma ivocação supimp[w], com a lista argumeto w uma qualquer lista de iteiros distitos. Desige-se tal úmero por NAT vi (). Só sabedo a dimesão da lista argumeto w, ão coseguimos determiar o valor exacto de NAT vi (), pois tal úmero depede da composição dessa lista: p.ex., se a lista for ão vazia (i.e. se >0) e estiver ordeada de forma decrescete, apeas uma atribuição a res é efectuada durate a execução do ciclo While (a melhor situação para o programa), ao passo que se a lista estiver ordeada de forma crescete, em cada execução do passo do ciclo é efectuada uma atribuição a res (a pior situação para o programa), e se a lista ão estiver ordeada, o úmero exacto de atribuições a res só pode ser determiado ispeccioado a lista argumeto cocreta w. Assim, uma hipótese seria (ver observação 1 aterior) efectuar tal cotagem (do úmero total de atribuições e testes realizados), cosiderado a pior situação, a melhor situação e em média. No etato, se quisermos apeas saber a ordem de gradeza do crescimeto de tal fução NAT vi (), etão, este caso, coseguimos obter tal ordem de gradeza procededo a miorações e majorações adequadas de tal úmero, o que é mais simples do que calcular o valor médio desse úmero. Notado que uma ivocação supimp[w], para além da iicialização (3 atribuições), é executada, para prox assumido os valores de 1 até, uma avaliação da guarda do ciclo e o míimo um teste (do If) e uma atribuição (prox=prox+1), e o máximo um teste (do If) e duas atribuições 434

17 (res=lista[[prox]]] e prox=prox+1), seguido-se uma avaliação fial da guarda do ciclo (com prox assumido o valor +1), é imediato que (para >0): 4 + NAT vi () prox=1 prox=1 4 + NAT vi () NAT vi () 4, para 4 Isto é, c1,c R + 0 N 0 0 c 1 NAT vi () c }, pelo que NAT vi () = Θ() ou seja, NAT vi () tem uma ordem gradeza de crescimeto liear. Passemos agora ao cálculo recursivo do supremo. Cotiuado a cosiderar que o supremo de uma lista vazia de iteiros é -, é fácil verificar que a fução Mathematica a seguir permite calcular o supremo de uma lista de iteiros (ou reais). Uma (primeira) versão recursiva para o cálculo do supremo: suprec = Fuctio[lista, If[ lista=={} (* ou Legth[lista]==0 *), -Ifiity, If[First[lista]>=supRec[Rest[lista]], First[lista], suprec[rest[lista]] ] ] ]; Seja (para atural) NC vr () o úmero de comparação com elemetos de w que ocorre uma ivocação suprec[w] (que podemos desigar por NC(supRec[w])), quado se assume que a lista argumeto w é uma qualquer lista de iteiros distitos. Ora, ao cotrário do que se passava a versão imperativa, aqui o úmero de comparações que ocorre uma ivocação suprec[w] ão depede apeas do úmero de elemetos da lista w, mas depede da própria composição dessa lista. Assim, como já referimos, o que se faz etão, em geral, estes casos é aalisar três possíveis situações: aquela em que a lista argumeto w (tem elemetos distitos e) tem um tipo de composição que é a melhor possível para o algoritmo em questão, o que os dá o úmero de comparações míimo do algoritmo - NC mi vr(); aquela em que a composição da lista argumeto é a pior possível, o que os dá o úmero de comparações máximo do algoritmo NC max vr(); e aquela em que se assume que a lista argumeto pode ser, com igual probabilidade, uma qualquer lista de iteiros distitos, e se procura determiar o úmero de comparações esperado, ou médio, do algoritmo NC med vr(). 435

18 Os valores mais importates são os valores máximo e médio. Mas comecemos por calcular primeiro os valores míimo e máximo, pois se eles forem da mesma ordem de gradeza, etão o úmero de comparações médio também será dessa ordem de gradeza, ão se torado essecial o seu cálculo exacto (ormalmete mais complicado). Caso o valor míimo e o valor máximo teham ordes de gradeza distitas, já será ecessário calcular o valor médio. Melhor caso O valor NC mi vr() desiga, etão, o úmero de comparações dado por NC(supRec[w]) quado se assume que a lista argumeto w é uma qualquer lista de iteiros distitos, ordeada de forma decrescete (a melhor situação para o algoritmo apresetado). Ora, este caso a execução de suprec[w] (mais precisamete, a ivocação de suprec[w] correspode a executar o corpo de suprec, quado o parâmetro lista assume/guarda a lista w, e tal execução) comporta-se como se segue: É avaliado o teste w=={} e se este for positivo (i.e. se =0), ão é feita qualquer comparação, sedo retorado -Ifiity e parado a execução; caso cotrário, é avaliada a guarda do If (que o caso em questão se traduz pela comparação First[w]>supRec[Rest[w]]) obtedo-se True, sedo retorado o valor de First[w], e parado a execução. É importate otar que a avaliação suprec[rest[w]], se tem que Rest[w] tem -1 iteiros distitos e cotiua a estar a melhor situação possível para o algoritmo (pois está ordeada de forma decrescete). Assim, é imediato que NC mi vr() é dado pela relação de recorrêcia: Se =0, etão NC mi vr() = 0. Se >0, etão NC mi vr() = 1 + NC mi vr(-1) e, resolvedo a rrelação de recorrêcia, obtém-se: NC mi vr() = (tal como para a versão imperativa). Pior caso O valor NC max vr() desiga, etão, o úmero de comparações dado por NC(supRec[w]) quado se assume que a lista argumeto w é uma qualquer lista de iteiros distitos, ordeada de forma crescete (a pior situação para o algoritmo apresetado). Ora, essa situação, a execução de suprec[w] comporta-se como se segue: Se w=={} (i.e. se =0), ão é feita qualquer comparação e acaba a execução. Se w!={} é avaliada a guarda do If (First[w]>supRec[Rest[w]]) que retora False, e é (de ovo) avaliado suprec[rest[w]]. Notado que a avaliação suprec[rest[w]], se tem que Rest[w] tem -1 elemetos distitos e cotiua a estar a pior situação possível para o algoritmo (pois está ordeada de forma decrescete), é imediato que NC max vr() é dado pela relação de recorrêcia: 436

19 Se =0, etão NC max vr() = 0. Se >0, etão NC max vr() = 1 + NC max vr(-1) e, resolvedo a relação de recorrêcia (idêtica à do problema das Torres de Haoi), obtém-se: NC max vr() = - 1 Agora, o úmero de comparações realizado já ão cresce liearmete, com o úmero de elemetos da lista, mas sim expoecialmete!!!! Trata-se de um resultado péssimo, em termos de eficiêcia 33, que tora este programa sem qualquer iteresse prático (salvo evetualmete para pequeos valores de ). Dada a eorme difereça etre o comportameto do pior e do melhor caso, tora-se importate vermos qual o valor esperado (médio) do úmero de comparações. De facto, dado o mau comportameto o pior caso, dificilmete este algoritmo recursivo teria algum iteresse prático. De qualquer forma, vejamos como calcular o úmero médio de comparações, o que servirá para ilustrar como se processa esta aálise. Aálise em média O valor NC med vr() desiga, etão, o úmero de comparações médio, ou esperado, de uma ivocação suprec[w] (a seguir desigado de NC(supRec[w])), quado se assume que a lista w pode ser, com igual probabilidade, uma qualquer lista de iteiros distitos. Ora, tem-se: Se w=={} (i.e. se =0), etão NC(supRec[w]) = 0. Caso cotrário, é avaliada a guarda do If (First[w]>supRec[Rest[w]]), com 1+NC(supRec[w]) comparações, e ou essa avaliação retora True, e ão é realizada mais ehuma comparação ou essa avaliação retora False, e é avaliado (outra vez) suprec[rest[w]] (NC(supRec[Rest[w]]) comparações). Assim, se >0, o úmero esperado de comparações é dado por: (1+NC(supRec[Rest[w]])) * Prob (First[w] suprec[rest[w]] retorar True) + (1+NC(supRec[Rest[w]])) * Prob (First[w]<supRec[Rest[w]] retorar False) Resta determiar qual a probabilidade de First[w] suprec[rest[w]] retorar True. Ora, como estamos a supor que que a lista w é uma qualquer lista (tirada ao acaso) de iteiros distitos, podemos assumir que qualquer elemeto dessa lista tem igual probabilidade de ser o maior deles todos (isto é, probabilidade 1/). E, o mesmo raciocíio se aplica o cálculo de NC(supRec[Rest[w]]). Somos assim coduzidos à seguite relação de recorrêcia: Se =0, etão NC med vr() = 0. Se >0, etão NC med vr() = (1 + NC med vr(-1)) * 1/ +(1 + NC med vr(-1)) * (-1)/ 33 O cálculo do tempo total de execução do algoritmo é um pouco maic complexo do que o simples úmero de comparações (omeadamete porque se tem de etrar com o tempo de avaliação de Rest[w] e do teste w!={}) e pode ser visto em [13]. De qualquer modo, a ordem de gradeza do tempo total de execução é também do mesmo tipo que a do úmero de comparações. 437