Tcnicas de Diviso e Conquista e de Programao Dinmica para a resoluo de Problemas de Otimizao

Francisco Vando Carneiro Moreira Gerardo Valdisio Rodrigues Viana Faculdade Loureno Filho Universidade Estadual do Cear Resumo
Encontrar o valor mximo ou mnimo de uma funo um problema bastante utilizado em diversas reas. Em geral, este valor chamado de "timo" pois corresponde ao melhor dentre todos os possveis num espao de solues viveis. Neste contexto define-se a otimizao, que pode ser restrita, quando a soluo atender determinadas condies impostas pelo problema, ou irrestrita, quando qualquer soluo dentro do domnio da funo investigada. Classificam-se como problemas mais difceis aqueles em que o espao de solues no contnuo, caracterizando a chamada Otimizao Discreta, ou Combinatria, definida assim: dado um conjunto A de elementos, deseja-se encontrar um subconjunto S A tal que a funo objetivo, aplicada aos elementos de S, possui o valor "timo" que pode ser de mximo (maior de todos) ou de mnimo (menor de todos). Como o nmero de opes para a escolha de S cresce de forma exponencial com o tamanho do conjunto A, mtodos exatos para obter a "soluo tima" precisam percorrer todo o espao, o que se torna impraticvel. Para isto existem os mtodos aproximados que correspondem s heursticas, meta-heursticas e algoritmos aproximativos. Dentre estes, destacam-se as tcnicas de Diviso e Conquista e de Programao Dinmica. Neste trabalho, mostramos o funcionamento destes dois algoritmos aplicados a alguns problemas conhecidos de otimizao combinatria.

Palavras-chave: Diviso e Conquista, Programao Dinmica, Algoritmos, Problema da Mochila.

1. INTRODUO
Dados, uma mochila com capacidade C e um conjunto A com n itens, onde cada item i A contm um peso Pi > 0 e uma utilidade, ou valor, Vi > 0, deseja-se determinar um subconjunto S A tal que a soma dos pesos dos elementos de S no ultrapasse a capacidade da mochila e a soma dos respectivos valores seja a maior possvel. Este artigo apresenta duas solues com paradigmas distintos para este clssico problema de otimizao combinatria. O primeiro algoritmo utiliza a estratgia de Diviso e Conquista na ordenao dos custos relativos (Peso/Valor) por intercalao (MergeSort). A

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

seguir utilizada uma heurstica gulosa para obter uma soluo aproximada. Estando os custos relativos em ordem no decrescente, o funcionamento do algoritmo guloso consiste em aceitar, a cada iterao, o primeiro item que aparecer, verificando a cada passo se a capacidade da mochila , ou no, ultrapassada. O resultado obtido por esta estratgia , em geral, prxima da melhor soluo possvel, ou seja, da soluo tima. O segundo algoritmo utiliza o mtodo da programao dinmica que sempre encontra a soluo tima, porm, com um tempo proporcional ao valor da entrada e no ao seu tamanho, como comum na anlise da funo de complexidade de um algoritmo. Veremos que, para uma entrada de um dado tamanho n (nmero de itens) com a capacidade da mochila C, o tempo de execuo deste algoritmo poder ser relativamente grande, portanto, invivel. Deste modo diz-se que o algoritmo de programao dinmica possui uma complexidade pseudo-polinomial. Nos experimentos computacionais foram consideradas algumas instncias do problema da Mochila para cada um dos algoritmos implementados. Com os resultados, dispostos numa tabela, possvel comparar a aproximao das solues e seus respectivos tempos de execuo.

2. DIVISO E CONQUISTA
O paradigma Diviso e Conquista consiste em dividir o problema a ser resolvido em partes menores, encontrar solues para as partes, e ento combinar as solues obtidas em uma soluo global. ZIVIANI (2007) cita o uso do paradigma para resolver problemas nos quais os subproblemas so verses menores do problema original geralmente leva a solues eficientes e elegantes, especialmente quando utilizado recursivamente. A Diviso e Conquista emprega modularizao de programas e frequentemente conduz a um algoritmo simples e eficiente. Esta tcnica bastante utilizada em desenvolvimento de algoritmos paralelos, onde os subproblemas so tipicamente independentes um dos outros, podendo assim serem resolvidos separadamente.

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Segundo FIGUEIREDO (2011), a tcnica de Diviso e Conquista consistem em 3 passos: Diviso: dividir a instncia do problema original em duas ou mais instncias menores, considerando-as como subproblemas. Conquista: resolver cada subproblema recursivamente. Combinao: combinar as solues encontradas em cada subproblema, compondo uma soluo para o problema original.

2.1 Vantagens
Indicado para aplicaes que tem restrio de tempo. de fcil implementao. Simplifica problemas complexos.

2.2 Desvantagens
Necessidade de memria auxiliar. Repetio de Subproblemas. Tamanho da pilha (nmero de chamadas recursivas e/ou armazenadas pode causar estouro de memria).

2.3 Algumas aplicaes

Multiplicao de inteiros longos. Menor distncia entre pontos. Ordenao rpida (quicksort) e por intercalao (mergesort). Pesquisa em rvore binria.

Um exemplo para ilustrar o uso dessa tcnica o algoritmo de ordenao de um vetor por intercalao (MergeSort). Sua representao pode ser feita atravs de uma rvore binria, conforme a indicada na Figura 1.

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Figura 1 Tcnica de Diviso e Conquista Fonte: MergeSort (FIGUEIREDO, 2011)

A altura (h) da rvore de execuo O (log n) e a quantidade de operaes em cada nvel da rvore assintoticamente igual a O(n), conclui-se ento que a complexidade do algoritmo no pior caso O(n log n) (VIANA e CINTRA, 2011). O MergeSort (ordenao por intercalao) divide o vetor de entrada em dois outros vetores com metade do tamanho do vetor original (em caso de tamanho mpar, um deles ter um elemento a mais que o outro). Cada um destes vetores menores ordenado recursivamente utilizando o mesmo procedimento. O MergeSort garante que os dois subproblemas tm tamanho da ordem de n/2, mas requer alocao de memria para o vetor temporrio de tamanho n. Este algoritmo, apresentado na Figura 2, usa o procedimento de intercalao (Merge) entre dois conjuntos previamente ordenados.

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Algoritmo MERGESORT (L, ini, fim) ENTRADA: um vetor L e as posies ini e fim SADA: o vetor L em ordem crescente da posio ini at a posio fim inicio se ini < fim meio = (ini + fim)/2 // diviso inteira se ini < meio MERGESORT(L, ini, meio) se (meio + 1) < fim MERGESORT(L, meio + 1, fim) MERGE(L, ini, meio, fim) f i m {MERGESORT} Figura 2 Algoritmo para o MergeSort Fonte: Viana e Cintra (2011, p. 30)

A Figura 3 mostra o algoritmo MERGE que faz a intercalao entre as duas partes de L.

PROCEDIMENTO MERGE ( L, ini, meio, fim ) ENTRADA: inteiros: ini, meio, fim; Vetor L[ini..fim] // L[ini..meio] = primeira srie ordenada // L[meio+1..fim] = segunda srie ordenada SADA: Registro L com uma nica srie ordenada // L[ini..fim] = srie intercalada /ordenada inicio i = ini; k = 1; j = meio + 1 enquanto ( i meio e j fim ) se ( L[i] L[j]) S[k] = L[i] i = i + 1 seno S[k] = L[j] j = j + 1 k = k + 1 // fim se // fim enquanto

continua

10

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

se ( i > meio ) p = j q = fim seno p = i q = meio para i = p at q S[k] = L[i] k = k + 1 // fim para L[ini..fim] = S[1..(fim-ini+1)] retorna (L) f i m {MERGE} Figura 3 Algoritmo de Intercalao Fonte: Viana e Cintra (2011)

3. ALGORITMO GULOSO PARA O PROBLEMA DA MOCHILA

Para resolver o problema da Mochila booleana (0/1) de forma aproximada foi utilizada uma heurstica gulosa apresentada na Figura 4. A descrio do algoritmo feita a seguir. A ordenao inicial refere-se ordem no decrescente do chamado custo relativo (Peso/Valor). A tcnica de Diviso e Conquista foi utilizada como um procedimento auxiliar para esta classificao. Em cada passo (iterao) do algoritmo selecionado ou escolhido o primeiro elemento do conjunto ordenado que caiba na mochila. Este objeto escolhido passa a fazer parte da soluo construda at ento. Observa-se, neste contexto, que foram unidas as duas tcnicas, resultando em um algoritmo, onde se tem a estratgia gulosa baseado no custo relativo atravs da ordenao MergeSort do paradigma de diviso e conquista, acima abordado.

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

11

Algoritmo MOCHILA_0/1_Guloso ENTRADA: C= capacidade da Mochila; n = nmero de itens V[1..n] vetor com os valores(custos) dos itens e P[1..n] vetor com os pesos dos itens SADA: X[1..n] vetor binrio que indica se o item i selecionado(1) ou no (0) Sol = soluo (valor mximo da Funo objetivo) Inicio Sol = 0 para i = 1 at n L[i] = V[i] / P[i] // fim para MERGESORT ( L, 1, n ) para i = 1 at n e enquanto C 0 j = C / P[i] // diviso inteira X[i] = min { j , 1 } C = C X[i]*P[i] Sol = Sol + X[i]*V[i] // fim para escreve ( Sol, X[j], j=1..n ) f i m {MOCHILA_0/1_Guloso} Figura 4 Algoritmo para o Problema da Mochila Fonte: Campello e Maculan (1994)

4. PROGRAMAO DINMICA
A Programao Dinmica (PD) pode ser caracterizada como um processo sequencial de tomada de decises, onde uma deciso tima global pode ser obtida atravs da otimizao de subproblemas (ou timos locais) individuais, seguindo o princpio de otimalidade de Bellman (DIAS et al, 2010). Na Programao Dinmica resolvem-se os problemas de pequena dimenso e guardam-se as solues em tabelas dinmicas, a fim de evitar redundncia de clculo, ou seja, uma soluo parcial obtida somente calculada uma nica vez. Este procedimento importante porque, diferentemente da tcnica de diviso e conquista, aqui cada subproblema dependente de pelo menos um outro. A soluo final obtida combinando as solues dos problemas menores

12

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

(ROSA, 2011). Pode-se dizer que a Programao Dinmica uma maneira esperta de transformar recurso em iterao, da ser chamada de Otimizao Recursiva. Aplica-se quando uma estratgia tima para resolver um problema continua a ser tima quando este subproblema de um problema maior, ou seja, somente solues timas dos subproblemas podem compor uma soluo tima do problema original (RIBEIRO, 1999). Muitas vezes quando o algoritmo direto tem complexidade exponencial, os algoritmos desenvolvidos por programao dinmica polinomial, reduzindo drasticamente o tempo de execuo. Outras vezes, como no caso do problema do caixeiro viajante, e da partio, a complexidade continua exponencial, mas de ordem mais baixa. A idia bsica da programao dinmica sugere, ento, uma estrutura geral para algoritmos projetados conforme Figura 5.

Figura 5 - Estrutura Geral da Programao Dinmica Fonte: Munari e Augusto (2007)

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

13

Na inicializao, a entrada decomposta em partes mnimas para as quais so obtidas respostas diretas, a cada iterao vai aumentando tamanho das partes e obtendo respostas correspondentes a partir das j geradas, at que as partes atingem o tamanho da entrada original. Quando ento sua soluo recuperada e o processo finalizado. Um exemplo clssico para a aplicao desta tcnica a ordem de produto de matrizes, citado em (ZIVIANI, 2007), que ilustra bem a tcnica de programao dinmica por meio de determinar a melhor forma de avaliar o produto de vrias matrizes: M = A1 x A2 x... x An, Onde cada Ai uma matriz com mi-1 linhas e mi colunas. A ordem na qual as matrizes so multiplicadas pode ter um efeito enorme no nmero total de operaes de adio e multiplicao necessrias para obter M. Por exemplo, se A1=A ( 5 0 x 2 0 ) ; A 2 = B ( 2 0 x 1 ) ; A 3 = C ( 1 x 1 0 ) e A 4 = D ( 1 0 x 1 0 0 ) , teramos as seguintes possibilidades de realizar o produto, conforme colocao de parnteses que indicam a prioridade indicada em cada uma das rvores da Figura 6. Esta ordem de execuo do produto de duas matrizes acarreta valores distintos do nmero de multiplicaes total e o que se deseja minimizar este valor: a. A x ( ( B x C ) x D ) b. ( ( A x B ) x C ) x D c. ( A x B ) x ( C x D ) d. A x ( B x ( C x D ) ) e. ( A x ( B x C ) ) x D

Figura 6 Possibilidades do produto de 4 matrizes. Os ns intermedirios contm os resultados parciais e a raiz, o produto AxBxCxD Fonte: Dasgupta et al (2008, p. 170)

14

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Considerando X ( p x q ) uma matriz com p linhas e q colunas, sabemos que o produto das matrizes X ( p x q ) por Y ( q x r ) existe e requer (p.q.r) multiplicaes para obter Z ( p x r ) = X Y . A instncia {m0, m1, . . .,mk, . . .,mn-1, mn) representa a sequncia do produto das matrizes A1, A2, . . .Ak . . . An com respectivas ordens ( m 0 x m 1 ) , ( m 1 x m 2 ) , . . . , ( m n - 1 x m n ) . Para o exemplo anterior teramos m0 = 50, m1 = 20, m2 = 1, m3 = 10 e m4 = 100 para definir as ordens das n=4 matrizes A, B, C e D. Na Tabela 1 mostrado o custo total de cada alternativa que corresponde ao total de multiplicaes requeridas em cada caso. Parentetizao a) A ( ( B C ) D) b) ( ( A B ) C ) D c) ( A B ) ( C D ) d) A ( B ( C D ) ) e) ( A ( B C ) ) D No de multiplicaes necessrias para o produto 20 . 1 . 10 + 20 . 10 . 100 + 50 . 20 . 100 50 . 20 . 1 + 50 . 1 . 10 + 50 . 10 . 100 50 . 20 . 1 + 1 . 10 . 100 + 50 . 1 . 100 1 . 10 . 100 + 20 . 1 . 100 + 50 . 20 . 100 20 . 1 . 10 + 50 . 20 . 10 + 50 . 10 . 100 Custo total 120200 51050 7000 103000 60200

Tabela 1 Escolha do melhor arranjo (c) para o produto de 4 matrizes Observa-se, neste exemplo, que para o pior arranjo, seriam necessrias 120200 multiplicaes, isto equivale a mais de 17 vezes o melhor arranjo (7000 multiplicaes). Este valor aproximadamente a mesma relao entre os tempos de execuo do algoritmo. O total P(n) de maneiras distintas para colocao de parnteses numa sequncia de n matrizes dada pela seguinte forma recursiva:

P(n) cresce de forma exponencial em funo de n, conforme mostra a Tabela 2.

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

15

n
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

P(n)
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440

n
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

P(n)
9694845 107 35357670 108 129644790 109 477638700 109 1767263190 1010 6564120420 1010 24466267020 1011 91482563640 1011 343059613650 1012 1289904147324 1013 4861946401452 1013 18367353072152 1014 69533550916004 1014 263747951750360 1015 1002242216651368 1016

Tabela 2 Nmero de alternativas para colocao de parnteses entre n matrizes O uso da Programao Dinmica para o problema do produto de matrizes tem por objetivo encontrar uma estrutura de parentetizao tima sem ter que gerar todas estas possibilidades. Considerando a notao para definir a cadeia Ai..j = Ai Ai+1 . . . Aj indicativa do produto da sequncia de matrizes Ai at Aj, podemos observar que A1..n = (A1..k) x (Ak+1..n). Pelo princpio da otimalidade da PD, se as subcadeias A1..k e Ak+1..n tem estruturas timas (ou sub-timas) podemos afirmar que A1..n ter estrutura tima. Usando a tabela dinmica contendo valores de multiplicaes escalares para calcular a matriz Ai..j ento, temos no h nenhum clculo e custo para multiplicar estas duas matrizes, ou seja: como mnimos pois Ai..i = Ai e

representa o menor custo para calcular Ai..k e Ak+1 .. j mais o

A definio recursiva para o custo mnimo de colocar parnteses no produto Ai..j :

16

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Para armazenarmento da soluo tima, pode-se utilizar uma matriz S, tal que o valor de S[i,j] contm o valor de k tal que M[i,j] mnimo. Os algoritmos apresentados nas figuras 7 e 8 resolvem o problema do produto de matrizes. Algoritmo PD_Produto_Matrizes ENTRADA: um vetor P contendo as ordens das n matrizes SADA: matrizes M e S contendo a soluo inicio para i =1 at n M[i,i]=0 para L= 2 at n para i= 1 at n-L+1 j = i + L 1 M[i,j] = para k= i at j-1 q = M[i,k] + M[k+1,j] + P[i]*P[k]*P[j] se q < M[i,j] M[i,j] = q S[i,j] = k return M[1,n] , S f i m {PD_Produto_Matrizes} Figura 7 Algoritmo para resolver o Problema do Produto de vrias matrizes por Programao Dinmica

Procedimento PRINT_CADEIA ( S, i, j ) inicio se i = j print A seno print ( PRINT_CADEIA ( S, i, S[ i , j ] ) PRINT_CADEIA ( S, S[ i , j ] + 1, j ) print ) f i m { PRINT_CADEIA } Figura 8 Gera a cadeia de caracteres referente sada do algoritmo da Figura 7

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

17

Os programas implementados em C# correspondentes aos algoritmos das Figuras 7 e 8 esto representados no Anexo A.2. Como exemplo de seu funcionamento foi executado o programa para uma dada instncia, obtendo os seguintes resultados mostrados a seguir na Figura 9.

Figura 9 Resultado do Programa do Anexo A.2

4.1 Vantagens da Programao Dinmica

Pode ser utilizada num grande nmero de problemas de otimizao discreta. No necessita de muita preciso numrica.

til para aplicar em problemas que exigem teste de todas as possibilidades.

18

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

4.2 Desvantagens
Necessita de grande espao de memria

A complexidade espacial pode ser exponencial

4.3 Algumas aplicaes Multiplicao de vrias matrizes Projeto de sistemas confiveis

5. PROBLEMA DA MOCHILA POR PROGRAMAO DINMICA

Conforme definido anteriormente, uma instncia do Problema da Mochila booleana definida por um conjunto com n itens com seus pesos Pi e valores Vi para uma mochila de capacidade C. Como o problema de maximizao a definio recursiva para a programao dinmica especfica para este problema dada por:

O algoritmo a seguir resolve o problema:

Algoritmo MOCHILA_0/1_PD ENTRADA: C= capacidade da Mochila; n = nmero de itens V[1..n] vetor com os valores(custos) dos itens e P[1..n] vetor com os pesos dos itens SADA: X[1..n] vetor binrio que indica se o item i selecionado(1) ou no (0) Sol = soluo (valor mximo da Funo objetivo)

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

19

inicio para i = 1 at C M[i,0] = 0 para j = 1 at n M[0,j] = 0 X[j] = 0 para i = 1 at C se P[j] > i M[i,j] = M[i,j 1] seno M[i,j] = max ( M[i,j 1] , M[i P[j] , j 1] + V[j] / / fim para Sol = M[C,n] / / rotina para determinar o vetor X (itens selecionados) aux = Sol j = n enquanto j > 0 se M[C,j] M[c,j1] X[j] = 1 aux = aux V[j] k = j 1 enquanto M[C,k] > aux M[c,k] = aux k = k 1 / / fim se j = j 1 / / fim enquanto fim { Mochila_0/1_PD }

Figura 10 Algoritmo para o Problema da Mochila por Programao Dinmica

20

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

6. EXPERIMENTOS COMPUTACIONAIS
Na abordagem utilizada para avaliar a aplicao de Tcnicas de Diviso e Conquista e Programao Dinmica para o problema da mochila, foram utilizadas oito instncias distintas. Cada instncia descrita em um arquivo de texto representa uma mochila com sua capacidade e seus itens identificados nas primeiras colunas da Tabela 3. Foi desenvolvida uma ferramenta em C#.NET 4.0 Asp.Net MVC utilizando a IDE Visual Studio 2010 Ultimate. A avaliao das instncias foi realizada em uma mquina com 2 GB de Ram, processador Intel Core 2 Duo e sistema operacional Microsoft Windows XP. A elaborao deste programa tem como objetivo ser de uso acadmico. Para efeito de comparao para o problema da mochila, resolvido tanto pela tcnica de Diviso e Conquista como por Programao Dinmica, retornamos o tempo gasto por cada tcnica, bem como a soluo encontrada. As demais colunas da Tabela 3 apresenta estes resultados.

Instncia

N Itens

Capacidade

Sol_1(PD)

Tempo_1

Sol_2(DC)

Tempo_2

Sol.tima Conhecida

1 2 3 4 5 6 7 8

KP4 KP100000 KP1000 KP2500 KP5000 KP7500 KP10000 KP20000

4 4 1000 2500 5000 7500 10000 20000

10 100000 500 295 2500 3804 5000 10000

70 70 1280 8560 37660 58165 77621 ***

0 0,046 0,171 0,125 2,718 6,250 11,484 -

70 70 1280 8560 37859 58164 77621 153576

0 0 0,171 0,125 2,718 6,250 11,484 -

70 70 12800 8560 37660 58260 77621 254921

Tabela 3 Resultados obtidos para algumas instncias do Problema da Mochila

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

21

Aps execuo do programa descrito no Anexo A.4 apresentamos os resultados com os valores de tempo expressos em segundos. Quando informados igual a 0 representam um tempo menor que 0.001s e se o contedo for *** indica que houve um estouro da pilha de execuo.

7. CONCLUSO
Os resultados mostraram que a eficincia das tcnicas e o tempo e recursos demandados esto intrinsecamente relacionados aos parmetros de configurao de entrada. Comparando as tcnicas de Diviso e Conquista e Programao Dinmica percebe-se que no caso da instncia com maior nmero de itens houve o estouro de recursos computacionais, sugerindo que a tcnica deve ser utilizada de forma controlada.

Divide-and-Conquer and Dynamic Programming Technical for solving Optimization Problems

Abstract
Find the maximum or minimum of a function is a problem widely used in various areas. In general, this is called "optimal value" because it corresponds to the best of all possible within a feasible solution space. In this context its defined the optimization, which can be restricted when the solution satisfy the conditions imposed by the problem, or unrestricted when any solution within domain of the function is investigated. Among these, the most difficult problems are those in which the solution set is not continuous, characterizing the so-called discrete or combinatorial optimization, defined as follows: Given a set A of elements and we want to find a subset S A such that the objective function applied to elements of S has the optimal value that can be maximum (greatest) or minimum (less of all). As the number of options for selecting S grows exponentially with the size of the set A, exact methods to obtain the "optimal solution" must search in the all space, which becomes impractical. For this there are approximate methods that correspond to heuristics, metaheuristics and approximation algorithms. Among these, there are the techniques of divide and conquer and dynamic programming. In this paper, we show the performance of these two algorithms applied to some known combinatorial optimization problems.

Keywords: Divide-and-Conquer, Dynamic Programming, Algorithm, Knapsack Problem.

22

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

Referncias
CAMPELLO, R.E. e MACULAN, N. (1994). Algoritmos e Heursticas. Desenvolvimento e Avaliao de Performance, Editora da Universidade Federal Fluminense, Niteri-RJ. DASGUPTA, S., PAPADIMITRIOU, C. and VAZIRANI, U. (2008). Algorithms. McGraw-Hill Higher Education. DIAS, B.; MARCATO, A.; SOARES, S.; SILVA, I.; OLIVEIRA, E.; BRANDI, R. e RAMOS, T. (2010). Utilizao do Algoritmo de Fechos Convexos na Programao Dinmica Estocstica: Simpsio Brasileiro de Sistemas Eltricos. FIGUEIREDO, J. Diviso e Conquista. (2011). Notas de Aula da disciplina Analise e Tcnicas de Algoritmo . Universidade Federal de Campina Grande. Disponvel em: http://www.dsc.ufcg.edu.br/~abrantes/CursosAnteriores/ATAL051/DivConq.pdf. MUNARI Jnior e AUGUSTO, P. (2007). Paradigmas e Tcnicas de Projeto de Algoritmos. Notas de Aula. ICMC/USP. RIBEIRO, C. (1999). Programao Dinmica. Notas de aula da disciplina Algoritmos e Estruturas de Dados II. Licenciatura em Engenharia Informtica e Computao. FEUP ROSA, J. (2011) Programao Dinmica. Paradigmas de Resoluo de Problemas. Slides. Universidade de So Paulo - Instituto de Cincia Matemtica e Computao. TOSCANI, L.A. e VELOSO, P.A.S. (2002). Complexidade de Algoritmos. Instituto de Informtica da UFRGS. Porto Alegre: Sagra Luzzatto. VIANA, G.V.R. e CINTRA, G.F. (2011). Pesquisa e Ordenao de Dados. Fortaleza: Publicao do Sistema UAB/UECE. ZIVIANI, N. (2007). Projeto e Algoritmos com implementaes em Pascal e C. So Paulo: Editora Thomson. Francisco Vando Carneiro Moreira Graduado em Cincia da Computao FLF Mestrando Acadmico em Cincia da Computao MACC/UECE e-mail: fvando@gmail.com

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

23

Gerardo Valdisio Rodrigues Viana Bacharel em Engenharia Mecnica UFC Licenciado em Matemtica UFC Doutor em Cincia da Computao UFC/USP e-mail: valdisio.viana@uece.br

24

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

ANEXOS
public List<Mitem> MergeSortDefault(List<Mitem> a) { if (a.Count == 1) return a; int middle = a.Count/2; List<Mitem> left = new List<Mitem>(middle); for (int i = 0; i < middle; i++) left.Add(a[i]); List<Mitem> right = new List<Mitem>(a.Count - middle); for (int i = 0; i < a.Count - middle; i++) right.Add(a[i + middle]); left = MergeSortDefault(left); right = MergeSortDefault(right); int leftptr = 0; int rightptr = 0; List<Mitem> sorted = new List<Mitem>(a.Count); ListaNew = new List<Mitem>(a.Count); for (int k = 0; k < a.Count; k++) { if (rightptr == right.Count || ((leftptr < left.Count) && ((Convert.ToDecimal(left[leftptr].peso)) <= (Convert.ToDecimal(right[rightptr].peso))))) { sorted.Add(left[leftptr]); leftptr++; } else if (leftptr == left.Count || ((rightptr < right.Count) && (Convert.ToDecimal(right[rightptr].peso)) <= (Convert.ToDecimal(left[leftptr].peso)))) { sorted.Add(right[rightptr]); rightptr++; } } return sorted; } } A.1 Programa em C# para o Problema da Mochila 0/1 utiliza a Tcnica de Diviso e Conquista para a ordenao e um Algoritmo Guloso para selecionar os itens

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

25

public List<ArrayList> Ordem_Multiplicacao_Matriz(string[] p, int num) { int q = 0; int i = 0; int j = 0; int k = 0; int l = 0; int[,] m = new int[sz, sz]; int[,] s = new int[sz, sz]; ArrayList M = new ArrayList(); ArrayList S = new ArrayList(); List<ArrayList> RetornoGeral = new List<ArrayList>(); int n = num; for (i = 1; i <= n; i++) m[i, i] = 0; for (l = 2; l <= n; l++) for (i = 1; i <= (n - l + 1); i++)
{

j = i + l - 1; m[i, j] = INF; for (k = i; k <= j - 1; k++)

{

q = m[i, k] + m[k + 1, j] + int.Parse(p[i - 1]) * int.Parse(p[k]) * int.Parse(p[j]); if (q < m[i, j])

{

m[i, j] = q; s[i, j] = k;
} } }

printSolutionParentheses(s, i - 1, j); printm(m, s, n); S.Add(resultadoSolution); M.Add(resultadoMatrizM); RetornoGeral.Add(M); RetornoGeral.Add(S); return RetornoGeral;
} }

A.2 Programa em C# para o Problema do Produto de Matrizes utiliza a Tcnica de Programao Dinmica para minimizar o nmero de multiplicaes

26

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

A.3 Tela do programa para o problema do Produto de Matrizes

Revista Cientfica da Faculdade Loureno Filho - v.8, n.1, 2011

27

public List<ClassDC.Mitem> MochilaProgramacaoDinamica(int C, List<Mitem> obj) int[,] dp = new int[C + 1, obj.Count]; int[,] d = new int[C + 1, obj.Count]; int[] D = new int[obj.Count]; for (int k = 0; k <= C; k++) if (k < obj[0].peso) { dp[k, 0] = 0; d[k, 0] = 0; } else { dp[k, 0] = obj[0].valor; d[k, 0] = 1;
}

for (int i = 1; i < obj.Count; i++) { for (int k = 0; k <= C; k++) { if (k < obj[i].peso) { dp[k, i] = dp[k, i - 1]; d[k, i] = 0;
}

else { if (dp[k, i - 1] > (dp[k - obj[i].peso, i - 1] + obj[i].valor)) { dp[k, i] = dp[k, i - 1]; d[k, i] = 0;
}

else { dp[k, i] = dp[k - obj[i].peso, i - 1] + obj[i].valor; d[k, i] = 1;

} } } }

int k1 = C; int ii = obj.Count - 1; while (ii >= 0) { D[ii] = d[k1, ii]; k1 -= (obj[ii].peso * D[ii]); ii--;
}

for (int i = 0; i < D.Length; i++) obj[i].x = D[i]; return obj;

}

A.4 Programa em C# para o Problema da Mochila por Programao Dinmica