Algoritmos para os Problemas da Mochila e do Corte de Estoque Tridimensional Guilhotinado

Transcrição

1 Algoritmos para os Problemas da Mochila e do Corte de Estoque Tridimensional Guilhotinado Thiago A. de Queiroz, Flávio K. Miyazawa, Instituto de Computação, IC, UNICAMP, , Campinas, SP tqueiroz@ic.unicamp.br, fkm@ic.unicamp.br Yoshiko Wakabayashi, Instituto de Matemática e Estatística, IME, USP , São Paulo, SP yw@ime.usp.br Eduardo C. Xavier Instituto de Computação, IC, UNICAMP, , Campinas, SP ecx@ic.unicamp.br RESUMO Neste trabalho consideramos os problemas da Mochila Ilimitada e do Corte de Estoque, em suas versões tridimensionais, restritos a cortes guilhotinados. Consideramos tanto o caso em que os objetos a serem cortados ou empacotados têm uma orientação fixa, bem como o caso em que rotações ortogonais são permitidas. Ambos os problemas são computacionalmente difíceis. Para o problema da Mochila Ilimitada Tridimensional, apresentamos um algoritmo exato que faz uso do conceito de reduced raster points e da estratégia de programação dinâmica. Para o problema do Corte de Estoque Tridimensional, apresentamos uma heurística baseada em geração de colunas que usa o algoritmo exato do problema da Mochila Ilimitada Tridimensional para gerar colunas. As soluções inteiras são obtidas da relaxação do programa inteiro, da reaplicação do método em instâncias residuais e por uma heurística construtiva. Os testes computacionais que realizamos com diversas instâncias adaptadas do mundo real e da literatura foram bastante satisfatórios: obtivemos soluções dentro de um pequeno tempo de processamento, indicando a viabilidade prática dos algoritmos propostos. PALAVRAS-CHAVE. Otimização Combinatória. Problema de Corte de Estoque Tridimensional. ABSTRACT This paper investigates the (Unbounded) 3D Knapsack and 3D Cutting Stock problems restricted to guillotine cuts. We consider the oriented case and also the case where orthogonal rotations are allowed. Both problems are computationally hard. For the 3D Knapsack problem, we present an exact algorithm that uses the concept of reduced raster points and dynamic programming strategy. For the 3D Cutting Stock problem, we present a column generation heuristic that uses the exact algorithm for the 3D Knapsack problem to generate columns. Integer solutions were obtained using the relaxation of the integer formulation, reapplication of the method for residual instances and by a constructive heuristic. Computational tests on instances adapted from real world and from the literature support the applicability of the approach. KEYWORDS. Combinatorial Optimization. Three-Dimensional Cutting Stock Problem.

2 1 Introdução O problema de cortar ou empacotar objetos ocorre rotineiramente em diversas situações práticas: no carregamento de contêineres ou caminhões, em cortes de vidro, madeira, espuma, etc. O objetivo consiste em minimizar as perdas no corte e/ou maximizar a ocupação do espaço utilizado no empacotamento. Em muitas aplicações reais, os objetos a serem cortados (ou empacotados) possuem três dimensões, e neste caso, os objetos grandes (os recipientes) são denominados contêineres, e os objetos pequenos são denominados caixas ou itens. Para definir os problemas e apresentar os algoritmos que serão tratados aqui, consideramos o espaço Euclidiano R 3, com sistema de coordenadas (x,y,z), em que a largura de um objeto é definida sobre o eixo x, o comprimento no eixo y e a altura no eixo z. As posições (0,0,0) e (L,C,A) do sistema de coordenadas representam, respectivamente, o canto inferior esquerdo frontal e o canto superior direito da parte de trás do contêiner em consideração. A posição de uma caixa dentro do contêiner é especificada pelo seu canto inferior esquerdo frontal. Claramente, as caixas devem ser colocadas nos contêineres, sem que ocorra sobreposição. As dimensões de um contêiner ou uma caixa x são dadas por uma tripla (l x,c x,a x ), indicando que x tem largura l x, comprimento c x e altura a x. Definimos a seguir os problemas e as siglas que usaremos para denotá-los. PROBLEMA DA MOCHILA ILIMITADA TRIDIMENSIONAL (3DM): São dados uma mochila/contêiner B = (L,C,A) e uma lista T de n (tipos de) caixas i com dimensões (l i,c i,a i ) e valores v i, para i = 1,...,n. O objetivo é determinar como empacotar num único contêiner B caixas cujas dimensões são iguais às de alguma caixa em T, de maneira a maximizar o valor total das caixas empacotadas. PROBLEMA DO CORTE DE ESTOQUE TRIDIMENSIONAL (3CE): São dados contêineres de dimensões B = (L,C,A), e uma lista T de n (tipos de) caixas i com dimensões (l i,c i,a i ) e demanda d i, para i = 1,...,n. O objetivo é determinar como cortar o menor número possível de contêineres B para produzir d i unidades de cada caixa i. Consideramos também as correspondentes versões destes problemas, denotadas por 3DM r e 3CE r, nas quais as caixas podem sofrer rotações ortogonais. Neste caso, se uma caixa com dimensões (l i,c i,a i ) faz parte da instância, então é permitido empacotar/cortar a mesma em uma das permutações de (l i,c i,a i ). Também supomos que cada caixa possa ser empacotada em pelo menos uma das orientações possíveis. Todos os problemas acima são NP-difíceis, porém, não se sabe se as respectivas versões de decisão estão em NP. Conforme as definições acima, uma instância para o problema 3DM ou 3DM r (respectivamente 3CE ou 3CE r ) é dada por uma tupla da forma (L,C,A,l,c,a,v) (respectivamente (L,C,A,l,c,a,d)). Supomos aqui que os números dados na instância são inteiros positivos, pois se não forem, podemos obter uma instância equivalente com valores inteiros fazendo uma mudança de escala. Observamos que os poblemas 3DM e 3DM r também podem ser vistos como problemas de corte: neste caso, considera-se que o objetivo é cortar o contêiner B para produzir caixas conforme as dimensões especificadas. Doravante, vamos usar a terminologia de corte. Vamos tratar do caso em que os cortes devem ser ortogonais e guilhotinados: cada corte deve ser paralelo ou ortogonal a cada um dos lados do contêiner e pode ser visto como um plano que é aplicado sobre toda a extensão do contêiner. Assim, se um corte é paralelo ao plano (x,y) por exemplo, para o especificar é suficiente indicar qual é a altura (entre 0 até A) desse corte. Cada parte residual do contêiner pode ser cortada novamente através de cortes guilhotinados, e o processo pode ser repetido até a obtenção das caixas desejadas. Na prática, tais tipos de corte são comuns, devido a restrições impostas pelas máquinas de corte. As versões uni- e bidimensionais do problema da mochila ilimitada que descrevemos vêm sendo estudadas desde a década de 60. Herz (1972) apresentou um algoritmo recursivo para a versão

3 bidimensional, denotada por 2DM, que obtém padrões, denominados canônicos, através do uso de pontos de discretização. Beasley (1985) propôs um algoritmo de programação dinâmica que usa os pontos de discretização para resolver variantes do problema 2DM. Cintra et al. (2008) apresentaram algoritmos de programação dinâmica para o problema 2DM, com os quais puderam resolver em pouco tempo computacional instâncias para as quais as soluções ótimas eram desconhecidas. Os primeiros algoritmos baseados em geração de colunas para o problema de Corte de Estoque uni- e bidimensionais, que denotamos respectivamente por 1CE e 2CE, foram desenvolvidos por Gilmore e Gomory (1961, 1963, 1965). Alvarez-Valdes et al. (2002) também trataram do problema 2CE apresentando um algoritmo baseado em geração de colunas, que faz uso da fórmula de recorrência proposta por Beasley (1985). Para o problema 3CE com demandas unitárias, existem vários algoritmos de aproximação. Csirik e van Vliet (1993) obtiveram um algoritmo com limite de desempenho assintótico 4,84. Miyazawa e Wakabayashi (2009) mostram que a versão com rotações é tão difícil de ser aproximada quanto a versão orientada e apresentam um algoritmo com fator de aproximação assintótico 4,89, também para o caso com demanda unitária. Cintra et al. (2007) mostram que estes fatores de aproximação também são válidos para o caso de demandas genéricas. Para os problemas 3DM e 3DM r, apresentamos aqui um algoritmo exato que faz uso do conceito de reduced raster points e da estratégia de programação dinâmica de Beasley. Para os problemas 3CE e 3CE r, apresentamos uma heurística baseada em geração de colunas que usa o algoritmo exato do problema da Mochila Ilimitada Tridimensional para gerar colunas. Neste trabalho estendemos a fórmula de recorrência proposta por Beasley, combinada com o conceito de reduced raster points de Scheithauer para o caso tridimensional, seguindo a mesma linha proposta em Cintra et al. (2008). Os algoritmos foram testados com instâncias reais adaptadas e obtidas de repositórios da Internet. Os resultados computacionais foram bastante satisfatórios para instâncias com poucos itens e grande demanda: soluções foram obtidas dentro de um tempo razoável de processamento, indicando a viabilidade prática dos algoritmos descritos. Para as instâncias adaptadas de Cintra et al. (2008), as soluções obtidas para os problemas 3CE e 3CE r estão a menos de 3% da solução ótima. Os algoritmos para os problemas 3DM e 3DM r são apresentados na Seção 2. Na Seção 3 apresentamos os algoritmos para os problemas 3CE e 3CE r. Na Seção 4 apresentamos os resultados computacionais. Por fim, algumas considerações finais são apresentadas na Seção 5. 2 Problema da Mochila Ilimitada Tridimensional Em um algoritmo exato para um problema de corte, uma questão fundamental é como gerar de modo mais eficiente possível todos os padrões de corte para uma dada instância desse problema. Um modo natural de gerar tais padrões é considerar os chamados pontos de discretização (definidos a seguir), que são nada mais do que posições no contêiner, em que um corte pode ser realizado (supondo que este corte vai gerar um item cujo canto inferior esquerdo frontal coincide com tal posição). Veremos, no entanto, que podemos nos restringir a um subconjunto de tais pontos. Considere uma instância do problema 3DM, dada por uma tupla da forma (L,C,A,l,c,a,v), conforme definimos anteriormente. Um ponto de discretização de largura (resp., de comprimento e de altura) é um valor i L (resp., j C e k A) obtido através de uma combinação linear inteira não-negativa de l = (l 1,...,l n ) (resp., c = (c 1,...,c n ) e a = (a 1,...,a n )). Denotamos por P, Q e R, o conjunto de todos os pontos de discretização de largura, comprimento e altura, respectivamente. Nos algoritmos desta seção, restringimo-nos a padrões de corte gerados através de pontos de discretização mais especializados, conhecidos por reduced raster points. Esses pontos foram introduzidos por Scheithauer (1997); e usados por Birgin et al. (2008), com bons resultados, no tratamento do problema de empacotamento de retângulos idênticos num retângulo. O conjunto de reduced raster points P (relativo a P) é definido como P = { L r : r P}, em que s = max{t P : t s}. Os conjuntos Q (relativo a Q) e e R (relativo a R) são definidos

4 analogamente. Para cada padrão que não usa os reduced raster points, existe um padrão equivalente cujos cortes são realizados (itens são empacotados) apenas em posições definidas por tais pontos. O número de padrões considerados desta maneira é em geral, bem menor que os definidos por pontos de discretização. Assim, para quaisquer números racionais x r L, y r C e z r A, definimos as respectivas funções: p(x r ) = max{i i P, i x r }; q(y r ) = max{ j j Q, j y r }; r(z r ) = max{k k R, k z r }. (1) Denotamos por RRP o algoritmo que calcula os reduced raster points usados para a geração dos padrões. Este algoritmo gera primeiro os pontos de discretização através do algoritmo de programação dinâmica DDP (Discretization using Dynamic Programming) apresentado por Cintra et al. (2008), e em seguida seleciona aqueles que são reduced raster points. A complexidade de tempo do algoritmo RRP é a mesma do algoritmo DDP: O(nD) onde D assume o valor máximo da dimensão sendo considerada: L, C ou A. Temos assim um algoritmo pseudo-polinomial. Quando D é pequeno, ou quando as dimensões das caixas não são tão pequenas em relação às dimensões do contêiner, ou se o número de itens não é grande, o algoritmo tem desempenho bastante satisfatório, como poderá ser visto nos testes computacionais. É possível diminuir o número de padrões e configurações de cortes evitando configurações dominadas por outras, conforme mencionado por Andonov et al. (2000). Neste trabalho não implementamos estas otimizações. Porém, como apresentado nos testes computacionais, o uso de padrões por reduced raster points são bastante simples e permitiram obter soluções muito rapidamente. 2.1 Algoritmo para o Problema 3DM Para calcular o valor ótimo de um padrão guilhotinado no caso tridimensional, estendemos a fórmula proposta por Beasley (1985). Assim, dado um contêiner de dimensões (l,c,a ), temos a seguinte fórmula de recorrência para G c (l,c,a ), o valor de uma solução ótima: G c (l,c,a ) := max g c (l,c,a ); max({g c (l,c,a ) + G c (p(l l ),c,a ) l P, l l /2}); max({g c (l,c,a ) + G c (l,q(c c ),a ) c Q, c c /2}); max({g c (l,c,a ) + G c (l,c,r(a a )) a R, a a /2}). (2) Na fórmula acima, g c (l,c,a ) é o valor máximo de uma única caixa que pode ser obtida/cortada considerando um contêiner de dimensões (l,c,a ). Este valor pode ser 0, caso nenhuma caixa possa ser obtida/cortada. Os conjuntos P, Q e R são obtidos a partir da execução do algoritmo RRP e as funções p(), q() e r() estão descritas em (1). Com isso, para uma instância I = (L,C,A,l,c,a,v), temos que G c (L,C,A) é o valor de uma solução ótima para tal instância. A seguir, descrevemos o algoritmo PD3DM (Programação Dinâmica para o problema da Mochila Ilimitada Tridimensional) que resolve de forma iterativa a recorrência (2) utilizando os conjuntos de reduced raster points P, Q e R, anteriormente descritos. Inicialmente, nas linhas 1.1 e 1.2, o algoritmo PD3DM invoca o algoritmo RRP e obtém os conjuntos P, Q e R. Nas linhas , armazena-se em G c (i, j,k) para cada contêiner de dimensões (p i,q j,r k ), com p i P, q j Q e r k R, o valor de uma caixa mais valiosa que pode ser obtida/cortada nestas dimensões, além de especificar qual é esta caixa através de item(i, j,k). A variável guil(i, j,k) indica a direção do corte da guilhotina (horizontal, vertical ou em profundidade). Se o valor é nulo, então nenhum corte deve ser feito. Já pos(i, j,k) indica a posição/ponto no eixo x, y ou z onde o corte de guilhotina deve ser feito. Nas linhas , o algoritmo encontra a solução ótima de forma iterativa a partir de soluções para contêineres menores. A solução para o contêiner da iteração atual é obtida através da melhor combinação de soluções já conhecidas para contêineres menores. Em outras palavras, dado um contêiner de dimensões (p i,q j,r k ), a solução ótima é obtida assim: para cada possível ponto p x onde um corte vertical V r pode ser feito, o algoritmo

5 Algoritmo 1: PD3DM Entrada: instância I = (L,C, A, l, c, a, v) do problema 3DM Saída: solução ótima para I 1.1 Faça P RRP(L,l 1,...,n ), Q RRP(C,c 1,...,n ), R RRP(A,a 1,...,n ), 1.2 onde P = (p 1 < p 2 <... < p m ), Q = (q 1 < q 2 <... < q s ), R = (r 1 < r 2 <... < r u ) 1.3 para i 1 até m faça 1.4 para j 1 até s faça 1.5 para k 1 até u faça 1.6 G c [i, j,k] max({v k 1 k n; l k p i, c k q j e a k r k } {0}) 1.7 item[i, j,k] max({k 1 k n; l k p i, c k q j, a k r k e v k = G c [i, j,k]} {0}) 1.8 guil[i, j, k] nulo para i 2 até m faça para j 2 até s faça para k 2 até u faça nn max(k 1 k i e p k p i /2 ) para x 1 até nn faça t max(k 1 k m e p k p i p x ) se G c [i, j,k] < G c [x, j,k] + G c [t, j,k] então G c [i, j,k] G c [x, j,k] + G c [t, j,k] pos[i, j,k] p x guil[i, j,k] V r nn max(k 1 k j e q k q j /2 ) para y 1 até nn faça t max(k 1 k s e q k q j q y ) se G c [i, j,k] < G c [i,y,k] + G c [i,t,k] então G c [i, j,k] G c [i,y,k] + G c [i,t,k] pos[i, j,k] q y guil[i, j,k] H z nn max(k 1 k k e r k r k /2 ) para z 1 até nn faça t max(k 1 k u e r k r k r z ) se G c [i, j,k] < G c [i, j,z] + G c [i, j,t] então G c [i, j,k] G c [i, j,z] + G c [i, j,t] pos[i, j,k] r z guil[i, j,k] P d 1.33 devolva G c (m,s,u). testa e determina a melhor solução comparando a melhor solução já conhecida com uma solução que poderia ser obtida com o corte vertical V r (linhas ); as linhas repetem o mesmo processo, porém para um corte na horizontal, H z ; e as linhas , para um corte em profundidade, P d. Por fim, na linha 1.33 o algoritmo devolve o valor de uma solução ótima. Podemos evitar a geração de padrões simétricos, considerando apenas os reduced raster points até a metade da respectiva dimensão do contêiner (feito nos passos 1.12, 1.19 e 1.26.) De fato, considere um contêiner de comprimento L e um corte de guilhotina ortogonal ao eixo x na posição t P, com t > L 2. Tal corte separa o contêiner corrente em dois contêineres menores, um de com-

6 primento t e outro de comprimento L t. Os padrões que podem ser obtidos considerando esses dois contêineres menores, também podem ser obtidos fazendo um corte de guilhotina na posição t = L t do contêiner original. Assim, se t P, tal corte é certamente considerado (já que t L 2 ); e se t / P, então o corte na posição t, que é considerado, gera dois contêineres que possibilitam obter os mesmos padrões que o corte em t permitiria. A complexidade de tempo do algoritmo PD3DM é influenciada diretamente pela complexidade de tempo do algoritmo RRP (linha 1.1). Se o número total de pontos de discretização para cada uma das dimensões L, C e A da mochila for m, s e u, respectivamente, então a complexidade de tempo do algoritmo PD3DM é O(nL+nC +na+m 2 su+ms 2 u+msu 2 ), sendo portanto um algoritmo pseudopolinomial. Por outro lado, a complexidade de espaço do algoritmo PD3DM é O(L+C +A+msu). 2.2 Problema 3DM r Na versão bidimensional do problema, em que rotações ortogonais são permitidas, cada caixa i com dimensões (l i,c i ) pode ser cortada em sua orientação original ou com as dimensões (c i,l i ), desde que l i c i, l i C e c i L. Já para o caso tridimensional, dada uma caixa i de dimensões (l i,c i,a i ), é possível obter até outras cinco novas dimensões através de rotações em torno de todos os eixos. O algoritmo PD3DM pode ser utilizado, sem sofrer modificações, para resolver o problema 3DM r. Para tanto, dada uma instância I do 3DM r, constrói-se outra instância I para o problema 3DM, tal que para cada caixa i em I de dimensões (l i,c i,a i ) e valor v i, adicionam-se às n caixas já existentes, novas caixas (viáveis) obtidas por rotações, de mesmo valor v i. Vamos denotar por PD3DM r esta variante que considera rotações. Note que foi possível considerar a versão com rotações desta maneira por se tratar do problema da mochila ilimitada, o qual permite que várias cópias de um mesmo item possam ser cortadas (ou empacotadas). 3 Problema do Corte de Estoque Tridimensional Antes de apresentar os algoritmos principais, apresentaremos algumas heurísticas construtivas usadas como subrotinas e para comparação dos algoritmos baseados na técnica de geração de colunas. 3.1 Heurísticas primais para o problema do corte de estoque tridimensional A heurística que apresentaremos é uma heurística híbrida. Esta gera um padrão dividido em níveis usando como subrotinas um algoritmo para o problema 2CE e um algoritmo para o problema 1CE. O primeiro algoritmo gera os níveis e o segundo empacota os níveis dentro de contêineres. Particularizando estas subrotinas, obteremos os dois algoritmos de interesse nesta seção: HFF3 e HFF3 r. Para definir os algoritmos para o problema 3CE, usaremos como subrotinas os algoritmos FFD (First Fit Decreasing) e o algoritmo HFF (Hybrid First Fit), desenvolvidos respectivamente para os problemas 1CE e 2CE. O algoritmo HFF usa dois algoritmos: HFF l e HFF c. Por simplicidade, vamos considerar que a demanda de cada item é unitária. Assim, dada uma instância (L,C, l, c) para o problema 2CE, o algoritmo HFF l ordena os itens de maneira decrescente por largura (l 1 l 2... l n ) e considera cada item i como um item unidimensional de tamanho c i. Em seguida, aplica o algoritmo FF (First Fit), FF(C, c), para obter o empacotamento dos itens em recipientes, F 1,...,F m. Chamaremos estes recipientes de faixas. Por fim, considera-se cada faixa F i como um item unidimensional de tamanho f (F i ) = max{l j : j F i } e obtém-se um empacotamento dos itens em placas usando o algoritmo FFD(L, f ). As faixas do algoritmo HFF l são geradas na direção da largura; denominamos de HFF c a variante deste algoritmo que gera as faixas na direção do comprimento. O algoritmo HFF executa as duas variantes e devolve uma solução de melhor valor. Para mais detalhes sobre o algoritmo HFF l, veja Chung et al. (1982).

7 Para a versão com rotações, vamos denotar por HFF x (resp. HFF y ) a versão do algoritmo HFF, que rotaciona os retângulos i (que podem ser rotacionados) de maneira a ter c i l i (resp. l i c i ) antes de aplicar os algoritmos HFF l e HFF c. O algoritmo HFF r executa estes algoritmos e devolve uma melhor solução. Baseado no algoritmo HFF, apresentamos o algoritmo H3CE. Este algoritmo primeiramente ordena os itens de maneira decrescente pela altura, e a cada iteração do laço, linha 2.3, gera um novo nível usando o algoritmo para o problema 2CE como subrotina, privilegiando o empacotamento de itens mais altos dentro de cada nível. No passo 2.7 procura-se inserir a maior quantidade de itens i, sem violar sua demanda e mantendo o empacotamento em no máximo um nível. Uma vez que todos os níveis foram gerados, estes são empacotados pelo algoritmo do problema 1CE em contêineres. Vamos denotar por HFF3 a (resp. HFF3 r a) o algoritmo H3CE que usa os algoritmos FFD e HFF (resp. HFF r ) como subrotinas. Note que os algoritmos HFF3 a e HFF3 r a geram e empacotam os níveis na direção do eixo da altura. Assim, vamos denotar por HFF3 c e HFF3 r c (resp. HFF3 l e HFF3 r l ) as correspondentes versões cujos níveis são gerados e empacotados na direção do comprimento (resp. largura). Denote por HFF3 (resp. HFF3 r ), o algoritmo que executa os algoritmos HFF3 a, HFF3 c e HFF3 l (resp. HFF3 r a, HFF3 r c e HFF3 r l ) e devolve o melhor empacotamento obtido. Algoritmo 2: H3CE. Entrada: instância I = (L,C, A, l, c, a, d) para o problema 3CE Saída: uma solução para I Subrotinas: algoritmos A e B para os problemas 1CE e 2CE, respectivamente. 2.1 Ordene os itens de I de maneira que a 1 a 2... a n. 2.2 m enquanto existe d i > 0, para algum i {1,...,n} faça 2.4 m m faça d = (d i ) onde d i = 0 para i = 1,...,n 2.6 para i 1 até n faça 2.7 d i max{t : t d i e B(L,C,l,c,d ) 1} 2.8 d i d i d i 2.9 faça N m B(L,C,l,c,d ) e h(n m ) = max{a i : d i > 0} seja P empacotamento dos níveis (N i ) em contêineres de altura A pelo algoritmo A (A,h) devolva P 3.2 Heurísticas baseadas em geração de colunas É bem conhecida a formulação do problema do corte de estoque como um programa linear inteiro. Para isso, considera-se P um conjunto de padrões de corte, P = m, e P uma matriz de ordem n m cujas colunas representam os padrões de corte, e d o vetor de demandas. Fazendo uso de uma variável x j, para cada j P, que indica o número de vezes que o padrão j é selecionado, obtém-se um programa linear inteiro, cuja relaxação linear é a seguinte: min{ x j : Px d, x j 0 j P}. (3) j P A ideia do algoritmo para o problema do corte de estoque é: resolver (3) através do método de geração de colunas proposto por Gilmore e Gomory (1961), considerar partes inteiras da solução e tratar as partes residuais através de uma heurística combinada com a ideia de geração de colunas. A estratégia consiste em aplicar o método Simplex, inicialmente com um número pequeno de colunas

8 de P como base, e ir gerando novas colunas à medida que forem necessárias. Ou seja, a cada iteração resolvemos o problema de gerar uma nova coluna a ser inserida. Em linhas gerais, cada caixa i tem um valor y i e devemos obter uma nova coluna/padrão com n i=1 y iz i > 1, sendo z i o número de vezes que o item i aparece no padrão. Deste modo, podemos usar um algoritmo para o problema da Mochila Ilimitada Tridimensional para obter tal padrão. O algoritmo usado para a resolução do programa linear (3) será denominado ResolvePL. No passo 3.1, a matriz I n n é a matriz diagonal correspondente aos n padrões. Cada qual com itens de um tipo e com uma orientação fixa. Para maiores detalhes sobre este método, recomendamos consultar Chvátal (1980). Algoritmo 3: ResolvePL. Entrada: instância I = (L,C, A, l, c, a, d) para o problema 3CE Saída: solução para o programa linear (3) onde colunas de P são os padrões de corte. Subrotina: algoritmo A para os problemas 3DM ou 3DM r. 3.1 Faça x d e B I n n 3.2 Resolva : y T B = [1,1,...,1] T n 3.3 z A (L,C,A,l,c,a,y) se y T z 1 então devolva (B,x) senão resolva: Bw = z faça t min( x j w j 1 j n, w j > 0) e s min( j 1 j n, para i 1 até n faça B i,s z i se i = s então x i t senão x i x i w i t vá para a linha 3.2 x j w j = t) A seguir, apresentamos o Algoritmo 4, denominado Resolve3CE, que recebe como entrada a solução devolvida pelo algoritmo ResolvePL (que pode ser fracionária). Este devolve uma solução inteira para o problema 3CE, utilizando uma heurística primal para obter padrões de corte que perturbem a geração da solução residual. A cada iteração do algoritmo Resolve3CE, resolve-se um sistema linear (linha 4.1) para uma dada instância I, para obter B e x. Em seguida, na linha 4.2, o algoritmo obtém o vetor x que representa as demandas atendidas pela parte inteira da solução fracionária. Então, caso exista alguma caixa i que tenha parte da sua demanda atendida por x, devolve-se o par (B,x ) e os padrões correspondentes a B. Em seguida, o algoritmo define uma nova instância (linhas ), chamada instância residual, I = (L,C,A,l,c,a,d ), sendo que o vetor d = (d 1,...,d n) contém o valor das demandas não atendidas de cada caixa i. Caso d seja nulo, o algoritmo finaliza (linha 4.11). Caso contrário, a execução continua (linha 4.12) para resolver a nova instância I I. Possivelmente, o vetor x devolvido pelo algoritmo ResolvePL poderá ter todos os seus componentes menores que 1. Neste caso, o vetor x será nulo e a subrotina A (linha 4.14) será usada para obter um bom padrão de corte. Ao obter tal padrão, as demandas são atualizadas e, nas linhas , caso exista alguma demanda, reinicia-se a execução na linha 4.1 para a nova instância residual. Note que o número de instâncias residuais resolvidas pelo algoritmo Resolve3CE pode ser, no pior caso, exponencial em n. Porém, claramente o algoritmo converge, pois a cada iteração, a demanda total das caixas é estritamente menor. O algoritmo A que usamos como subrotina do algoritmo Resolve3CE é o algoritmo híbrido HFF3, que descrevemos na Seção Problema 3CE r O algoritmo Resolve3CE pode ser usado para resolver o problema 3CE r. Para isto, basta usar um algoritmo para o problema 3CE r como subrotina do algoritmo Resolve3CE e um algoritmo para o problema 3DM r como subrotina para o problema ResolvePL. Nos nossos testes computacionais,

9 Algoritmo 4: Resolve3CE. Entrada: instância I = (L,C, A, l, c, a, d) para o problema 3CE Saída: uma solução para I Subrotina: algoritmo A para o problema 3CE ou o problema 3CE r. 4.1 (B,x) ResolvePL(L,C,A,l,c,a,d) 4.2 para i 1 até n faça xi x i 4.3 se existe i tal que xi > 0 para algum 1 i n então 4.4 devolva (B,x1,...,n ) (mas NÃO PARE) 4.5 para i 1 até n faça 4.6 para j 1 até n faça d i d i B i, j x j n 0, l (), c (), a (), d () para i 1 até n faça se d i > 0 então n n + 1, l l (l i ), c c (c i ), a a (a i ), d d (d i ) se n = 0 então PARE n n, l l, c c, a a, d d vá para a linha 4.1 devolva um padrão de A (L,C,A,l,c,a,d) com maior volume e atualize as demandas. se existe i tal que d i > 0 para 1 i n então vá para a linha 4.1 dado o problema 3CE r, usamos os algoritmos HFF3 r e PD3DM r como subrotinas. E, então, para diferenciar, denotamos esta versão por Resolve3CE r. 4 Testes Computacionais Os testes foram realizados com várias instâncias, algumas obtidas adaptando-se instâncias de trabalhos da literatura. Por limitação de espaço, apresentamos apenas os resultados para as instâncias adaptadas do trabalho de Cintra et al. (2008). Tais instâncias foram inicialmente desenvolvidas para o caso bidimensional. Deste modo, para cada caixa dessa instância, adicionamos uma terceira dimensão, obtida de forma aleatória ou sorteada de alguma das dimensões já usadas por alguma caixa. Realizamos o mesmo procedimento para obter a terceira dimensão do contêiner. No total, consideramos apenas as 12 primeiras instâncias devido às limitações do hardware para tratar contêineres com dimensões maiores que 2000 unidades. Os algoritmos propostos foram codificados na linguagem C e os testes executados em um computador com processador Intel R Core T M 2 Duo 1,66 GHz, memória de 2 GB e sistema operacional Linux. Os sistemas lineares (na geração de colunas) foram resolvidos pelo pacote Coin-OR CLP. 4.1 Testes Computacionais para o Problema da Mochila Ilimitada Tridimensional Nas tabelas 1 e 2, apresentamos os testes para os problemas 3DM e 3DM r, respectivamente. Os testes foram realizados usando raster points, uma vez que o número destes pontos foi na média 50% menor que o de pontos de discretização. Isto levou a uma boa economia no tempo de processamento. Em cada linha, temos os seguintes dados: nome da instância; número de caixas diferentes; dimensões do contêiner; número total de raster points m, s e u nas dimensões L, C e H da mochila; porcentagem da mochila ocupado pelo volume das caixas; e o tempo (de CPU) gasto, em segundos. Caso o tempo seja 0, isto significa que foi gasto menos de 0,001s para resolver a referida instância. Consideramos aqui que o valor v i de cada caixa é o seu volume. Note que para todas as instâncias

10 listadas, as soluções ótimas foram obtidas em no máximo 0,001s. Instância Num. Caixas Dim. da Mochila m s u Vol. Util. (%) Tempo (s) gcut1_3d 10 (250, 250, 250) ,649 0,0 gcut2_3d 20 (250, 250, 250) ,127 0,0 gcut3_3d 30 (250, 250, 250) ,417 0,0 gcut4_3d 50 (250, 250, 250) ,352 0,0 gcut5_3d 10 (500, 500, 500) ,826 0,0 gcut6_3d 20 (500, 500, 500) ,781 0,0 gcut7_3d 30 (500, 500, 500) ,172 0,0 gcut8_3d 50 (500, 500, 500) ,074 0,0 gcut9_3d 10 (1000, 1000, 1000) ,224 0,0 gcut10_3d 20 (1000, 1000, 1000) ,986 0,0 gcut11_3d 30 (1000, 1000, 1000) ,344 0,0 gcut12_3d 50 (1000, 1000, 1000) ,303 0,0 Tabela 1: Resultados para as instâncias de 3DM adaptadas de Cintra et al. (2008). Instância Num. Caixas Dim. da Mochila m s u Vol. Util. (%) Tempo (s) gcut1_3dr 10 (250, 250, 250) ,067 0,0 gcut2_3dr 20 (250, 250, 250) ,095 0,0 gcut3_3dr 30 (250, 250, 250) ,875 0,0 gcut4_3dr 50 (250, 250, 250) ,625 0,0 gcut5_3dr 10 (500, 500, 500) ,826 0,0 gcut6_3dr 20 (500, 500, 500) ,654 0,0 gcut7_3dr 30 (500, 500, 500) ,562 0,0 gcut8_3dr 50 (500, 500, 500) ,550 0,0 gcut9_3dr 10 (1000, 1000, 1000) ,209 0,0 gcut10_3dr 20 (1000, 1000, 1000) ,151 0,0 gcut11_3dr 30 (1000, 1000, 1000) ,974 0,0 gcut12_3dr 50 (1000, 1000, 1000) ,384 0,0 Tabela 2: Resultados para as instâncias de 3DM r adaptadas de Cintra et al. (2008). Como era de se esperar, ao permitir rotações, pode ocorrer um melhor aproveitamento do contêiner. De fato, comparando-se o volume de utilização médio do contêiner para todas as instâncias na Tabela 1 com relação à Tabela 2, nota-se que a diferença percentual chega a 3,96%. 4.2 Testes Computacionais para o Problema do Corte de Estoque Tridimensional A seguir, apresentamos nas tabelas 3 e 4 os testes para os problemas 3CE e 3CE r. Em cada uma das tabelas, cada coluna refere, respectivamente, a: nome da instância de entrada; solução dada pelo algoritmo Resolve3CE; limitante inferior (LI) para o valor de uma solução ótima inteira, obtido da resolução da relaxação linear (3) pelo algoritmo ResolvePL; diferença percentual entre a solução obtida pelo algoritmo ResolveCE e limitante inferior (LI); o tempo gasto, em segundos; o número de colunas geradas; a solução obtida apenas pela execução do algoritmo HFF3 (ou HFF3 r ); melhora percentual entre a solução obtida pelo algoritmo Resolve3CE (resp. Resolve3CE r ) e o algoritmo HFF3 (resp. HFF3 r ). Observando as tabelas 3 e 4, é possível notar que a solução do algoritmo Resolve3CE difere de no máximo 3,02% do limitante inferior. Comparando o desempenho do algoritmo Resolve3CE (resp. Resolve3CE r ) com a solução obtida pelo algoritmo HFF3 (resp. HFF3 r ), a melhora nos resultados foi de 16,28% (resp. 23,75%) na média. Em relação ao tempo gasto para resolver cada

11 instância, no pior caso não se ultrapassaram os 60 segundos para o problema 3CE e 260 segundos para o problema 3CE r. Instância Solução do LI Diferença Tempo Colunas HFF3 Melhora sobre Resolve3CE Percentual (s) Geradas HFF3 gcut1_3d ,000% 0, ,00% gcut2_3d ,352% 1, ,18% gcut3_3d ,852% 7, ,96% gcut4_3d ,749% 56, ,76% gcut5_3d ,000% 0, ,00% gcut6_3d ,435% 0, ,13% gcut7_3d ,578% 1, ,51% gcut8_3d ,346% 41, ,17% gcut9_3d ,538% 0, ,38% gcut10_3d ,000% 0, ,00% gcut11_3d ,370% 3, ,49% gcut12_3d ,798% 29, ,20% Tabela 3: Resultados para as instâncias do problema 3CE adaptadas de Cintra et al. (2008). Instância Solução do LI Diferença Tempo Colunas HFF3 r Melhora sobre Resolve3CE r Percentual (s) Geradas HFF3 r gcut1_3dr ,299% 0, ,29% gcut2_3dr ,546% 8, ,60% gcut3_3dr ,941% 193, ,71% gcut4_3dr ,088% 237, ,23% gcut5_3dr ,000% 0, ,52% gcut6_3dr ,087% 1, ,11% gcut7_3dr ,590% 21, ,33% gcut8_3dr ,838% 211, ,66% gcut9_3dr ,695% 0, ,67% gcut10_3dr ,427% 2, ,97% gcut11_3dr ,012% 166, ,27% gcut12_3dr ,784% 253, ,55% Tabela 4: Resultados para as instâncias do problema 3CE r adaptadas de Cintra et al. (2008). 5 Considerações Finais Para o problema da Mochila Ilimitada Tridimensional (3DM), os resultados obtidos com as instâncias exibidas e algumas outras mostraram que, no caso em que rotações ortogonais são permitidas, os volumes utilizados são maiores (a melhora na utilização do volume do contêiner chegou aos 3,96%, na média). Isto porém é natural, já que o domínio das soluções viáveis cresce. O destaque fica para o fato de que todas as soluções ótimas foram obtidas em tempo muito inferior a 0,1s, mesmo no caso com rotações, onde mais soluções viáveis devem ser testadas. Pretendemos realizar mais testes com instâncias maiores, como as da OR-Library, descrita por Beasley (1990), para verificar até quais tamanhos de instâncias podemos resolver exatamente, em tempo razoável, com o algoritmo proposto. Para o problema do Corte de Estoque Tridimensional (3CE), foram obtidas soluções dentro de 3% do limitante inferior em poucos minutos para instâncias com poucos itens diferentes e grande demanda por item. Tal comparação é ainda mais favorável quando comparamos com uma heurística híbrida.

12 Os diversos testes realizados, além daqueles apresentados neste trabalho, indicam que os algoritmos propostos são bastante úteis para resolver problemas reais de pequeno a médio porte. Agradecimentos: Os autores agradecem as agências de fomento CAPES, CNPq e FAPESP, pelo auxílio financeiro recebido. Além disso, agradecem aos revisores pelas valiosas sugestões. Referências R. Alvarez-Valdes, A. Parajon e J. M. Tamarit. A computational study of lp-based heuristic algorithms for two-dimensional guillotine cutting stock problems. OR Spectrum, 24(2): , R. Andonov, V. Poirriez e S. Rajopadhye. Unbounded knapsack problem: Dynamic programming revisited. European Journal of Operational Research, 123: , J. E. Beasley. Algorithms for unconstrained two-dimensional guillotine cutting. Journal of the Operational Research Society, 36(4): , J. E. Beasley. OR-Library: distributing test problems by electronic mail. Journal of the Operational Research Society, 41(11): , E. G. Birgin, R. D. Lobato e R. Morabito. An effective recursive partitioning approach for the packing of identical rectangles in a rectangle. Journal of the Operational Research Society, Aceito; DOI: /jors F. R. K. Chung, M. R. Garey e D. S. Johnson. On packing two-dimensional bins. SIAM Journal on Algebraic and Discrete Methods, 3:66 76, V. Chvátal. Linear Programming. W. H. Freeman and Company, New York, G. Cintra, F. K. Miyazawa, Y. Wakabayashi e E. C. Xavier. A note on the approximability of cutting stock problems. European Journal on Operations Research (Elsevier Science), 34: , G. F. Cintra, F. K. Miyazawa, Y. Wakabayashi e E. C. Xavier. Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation. European Journal of Operational Research, 191:59 83, Coin-OR CLP. Linear programming solver: An open source code for solving linear programming problems. J. Csirik e A. van Vliet. An on-line algorithm for multidimensional bin packing. Operations Research Letters, 13: , P. Gilmore e R. Gomory. A linear programming approach to the cutting stock problem. Operations Research, 9: , P. Gilmore e R. Gomory. A linear programming approach to the cutting stock problem - part II. Operations Research, 11: , P. Gilmore e R. Gomory. Multistage cutting stock problems of two and more dimensions. Operations Research, 13:94 120, J. C. Herz. A recursive computational procedure for two-dimensional stock-cutting. IBM Journal of Research Development, páginas , 1972.

13 F. K. Miyazawa e Y. Wakabayashi. Three-dimensional packings with rotations. Computers and Operations Research, 36: , G. Scheithauer. Equivalence and dominance for problems of optimal packing of rectangles. Ricerca Operativa, 27:3 34, 1997.