UNIVERSIDADE FEDERAL FLUMINENSE ESCOLA DE ENGENHARIA

PROGRAMA DE PÓS-GRADUAÇÃO STRICTO SENSU EM ENGENHARIA DE PRODUÇÃO CURSO DE DOUTORADO EM ENGENHARIA DE PRODUÇÃO

ANDRÉ SOARES VELASCO

ALGORITMOS HÍBRIDOS PARA O PROBLEMA DE CORTE BIDIMENSIONAL

Tese apresentada ao Curso de Doutorado em

Engenharia de Produção da Universidade

Federal Fluminense como requisito parcial

para obtenção do Grau de Doutor em

Engenharia de Produção.

Professor Orientador:

Prof. EDUARDO UCHOA BARBOZA, DSc.

Niterói 2017

Ficha Catalográfica elaborada pela Biblioteca da Escola de Engenharia e Instituto de Computação da UFF

V433 Velasco, André Soares

Algoritmos híbridos para o problema de corte bidimensional /

André Soares Velasco. – Niterói, RJ : [s.n.], 2017.

134 f.

Tese (Doutorado em Engenharia de Produção) - Universidade

Federal Fluminense, 2017.

Orientador: Eduardo Uchoa Barboza.

1. Pesquisa operacional. 2. Metaheurística. 3. Programação

inteira. 4. Programação dinâmica. I. Título.

CDD 658.4034

ANDRÉ SOARES VELASCO

ALGORITMOS HÍBRIDOS PARA O PROBLEMA DE CORTE BIDIMENSIONAL

Tese apresentada ao Curso de Doutorado em

Engenharia de Produção da Universidade

Federal Fluminense como requisito parcial

para obtenção do Grau de Doutor em

Engenharia de Produção.

Aprovada em 22 de março de 2017

BANCA EXAMINADORA

____________________________________________ Professor Orientador: Eduardo Uchoa Barboza, D.Sc.

Universidade Federal Fluminense

____________________________________________ Artur Alves Pessoa, D.Sc.

Universidade Federal Fluminense

____________________________________________ Luiz Satoru Ochi, D.Sc.

Universidade Federal Fluminense

____________________________________________ Geraldo Galdino de Paula Junior, D.Sc.

Universidade Estadual do Norte Fluminense

____________________________________________ Reinaldo Morabito Neto, D.Sc.

Universidade Federal de São Carlos

Niterói 2017

DEDICATÓRIA

A minha doce mãe Hudinéa†, ao meu corajoso irmão Julinho† e

aos queridos avós Irani e Florentino†.

AGRADECIMENTOS

Agradeço a Deus, por ter me conduzido e iluminado em todos os momentos. Ao meu orientador Eduardo Uchoa Barboza, pela valiosa orientação, amizade, compreensão e, sobretudo, pela confiança depositada no desenvolvimento deste trabalho. Aos amigos Frederico Galaxe e Marcos Roboredo, pelo apoio e amizade imprescindíveis para essa conquista. A vocês minha eterna gratidão. Aos professores Artur Alves Pessoa, Luiz Satoru Ochi, Geraldo Galdino de Paula Junior e Reinaldo Morabito Neto, membros da comissão examinadora, pelas sugestões apresentadas para o aperfeiçoamento deste trabalho. Aos meus amigos, colegas de doutorado e servidores da UFF: Leonardo Lube, Alex Barcellos, Ricardo Gurgel, Wirley Almeida, Diogo Nadai, Ricardo Torres, Ronaldo Rangel, Elaine Moreira, Roberta Ramalho, Augusto Pimentel, Philippe Leal, Tiago Santos, Ailton Ferreira, Érik Oliveira, Liana Souza, Hugo Kramer, Max Oliveira, Daniel Dias, Luiz Santanna, Eduardo Montalvão, José Mauricio Brasil, Luiz Aizemberg, Ana Paula dos Santos, Mario Brazão, Hermilcinéa Alves, Tânia Machado e tantos outros que, direta ou indiretamente, contribuíram para realização deste trabalho, não hesitando momento algum em me incentivar. Ao querido casal Marcelo e Danielle Velasco e a todos os demais familiares, pelo apoio irrestrito e palavras de encorajamento nos momentos difíceis. Ao meu filho Pedro Julio, pela sua presença na minha vida ser a maior fonte de encorajamento para realização deste trabalho. Ao Instituto Federal Fluminense e a CAPES pelo incentivo e apoio financeiro durante o período de doutorado.

RESUMO

O presente trabalho tem como objetos de estudo dois tipos de Problemas de Corte e Empacotamento, conhecidos na literatura como Problema de Corte Bidimensional Guilhotinado Restrito (PCBGR) e Problema de Corte de Estoque Bidimensional Guilhotinado (PCEBG), ambos pertencendo à classe NP-difícil, nos casos com e sem rotação de itens. Esses problemas possuem grande aplicabilidade em diversos setores produtivos que consideram as ações de corte na transformação de materiais em produtos semiacabados ou finais, tais como: metal mecânico, moveleiro, rochas ornamentais, entre outros. Primeiramente, são apresentadas as contribuições para o PCBGR: o algoritmo RG2D, fundamentado no Reactive Greedy Randomized Adaptive Search Procedure (GRASP Reativo) e implementado a partir de melhorias feitas no algoritmo GRASP-2D (G2D), para tratar o problema em destaque; o algoritmo X, baseado em Programação Inteira e capaz de provadamente obter os pesos ótimos para a relaxação de espaço de estados da Programação Dinâmica proposta em (CHRISTOFIDES; HADJICONSTANTINOU, 1995); o algoritmo X2, proposto como uma generalização de X que usa pesos bidimensionais para obter limites ainda mais fortes; o algoritmo X2H que consiste na adaptação de X2 para transformá-lo em uma heurística primal; o método X2D, resultante da combinação desses quatro elementos, foi testado em um grande conjunto de instâncias e mostrou ser capaz de encontrar soluções com garantias de qualidade ou mesmo certificado de otimalidade nas variantes com e sem rotação dos itens. A seguir, tendo como objeto de estudo o PCEBG, as contribuições são: a proposta de um algoritmo híbrido que combina a técnica de Geração de Colunas com Programação Dinâmica e o novo algoritmo RG2D. Os resultados computacionais obtidos até o momento foram bastante positivos. Em todas as instâncias testadas as soluções encontradas nunca ficaram mais do que 1 unidade além do limite inferior dado pela Geração de Colunas.

Palavras-chave: Corte Bidimensional, GRASP, Programação Dinâmica, Programação Inteira, Geração de Colunas.

ABSTRACT

The present work addresses two types of Cutting and Packing Problems, known in the literature as Two-dimensional Guillotine Restricted Cutting Problem (TGRCP) and Two-dimensional Guillotine Cutting Stock Problem (TGCSP), both in the NP-hard class, with and without item rotation. Those problems have applications in industry, where cutting operations are performed for transforming raw stocks into final or semi-final products, in sectors like metallurgy, furniture, glass, ornamental stones, among others. Firstly, the following contributions are presented: the RG2D algorithm based on the Reactive Greedy Randomized Adaptive Search Procedure (GRASP Reactive) and implemented from improvements made in the GRASP-2D (G2D) algorithm, to address the highlighted problem; the Algorithm X, based on Integer Programming and capable of provably to obtain the optimal weights for the Dynamic Programming state space relaxation proposed in (CHRISTOFIDES; HADJICONSTANTINOU, 1995); the X2 algorithm proposed as a generalization of X that uses two-dimensional weights in order to obtain even stronger upper bounds; the X2H algorithm that consists in the adaptation of X2 to transform it into a primal heuristic; the method X2D that results from the combination of those four elements was tested in a large set of instances and showed to be able to find solutions with quality guarantees or even certificate of optimality. Next, in order to handle TGCSP, the contributions are: hybrid algorithms that combine in different ways Column Generation with Dynamic Programming and the new RG2D algorithms are proposed. The computational results obtained so far were very positive. In all tested instances, the final solutions were never more than 1 unit above the lower bound given by the Column Generation.

Keywords: Two-dimensional Cutting, GRASP, Integer Programming, Dynamic Programming, Column Generation.

LISTA DE TABELAS

Tabela 4.1: Instância de Christofides e Whitlock Adaptada...................................................................53 Tabela 4.2: Resultados nas Instâncias Clássicas sem Rotação e com Peso ........................................... 78 Tabela 4.3: Resultados nas Instâncias Clássicas sem Rotação e sem Peso ........................................... 79 Tabela 4.4: Resultados nas Instâncias APT sem Rotação e com Peso .................................................. 80 Tabela 4.5: Resultados nas Instâncias APT sem Rotação e sem Peso .................................................. 80 Tabela 4.6: Resultados nas Instâncias gcut sem Rotação e sem Peso ................................................... 81 Tabela 4.7: Resultados nas Instâncias Clássicas com Rotação e com Peso .......................................... 82 Tabela 4.8: Resultados nas Instâncias Clássicas com Rotação e sem Peso ........................................... 82 Tabela 4.9: Resultados nas Instâncias APT com Rotação e com Peso ................................................. 83 Tabela 4.10: Resultados nas Instâncias APT com Rotação e sem Peso ................................................ 83 Tabela 4.11: Resultados nas Instâncias gcut com Rotação e sem Peso ................................................. 84 Tabela 5.1: Resultados nas Instâncias Clássicas sem Rotação e com Peso ......................................... 106 Tabela 5.2: Resultados nas Instâncias Clássicas sem Rotação e sem Peso ......................................... 107 Tabela 5.3: Resultados nas Instâncias Randômicas da Classe 1 sem Rotação e sem Peso ................. 109 Tabela 5.4: Resultados nas Instâncias Randômicas da Classe 2 sem Rotação e sem Peso ................. 110 Tabela 5.5: Resultados nas Instâncias Randômicas da Classe 3 sem Rotação e sem Peso ................. 111 Tabela 5.6: Resultados nas Instâncias APT sem Rotação e com Peso ................................................ 112 Tabela 5.7: Resultados nas Instâncias APT sem Rotação e sem Peso ................................................ 112 Tabela 5.8: Resultados nas Instâncias gcut sem Rotação e sem Peso ................................................. 113 Tabela 5.9: Resultados nas Instâncias Clássicas com Rotação e com Peso ........................................ 114 Tabela 5.10: Resultados nas Instâncias Clássicas com Rotação e sem Peso ....................................... 114 Tabela 5.11: Resultados nas Instâncias Randômicas da Classe 1 com Rotação e sem Peso ............... 115 Tabela 5.12: Resultados nas Instâncias Randômicas da Classe 2 com Rotação e sem Peso ............... 115 Tabela 5.13: Resultados nas Instâncias Randômicas da Classe 3 com Rotação e sem Peso ............... 116 Tabela 5.14: Resultados nas Instâncias APT com Rotação e com Peso ............................................. 117 Tabela 5.15: Resultados nas Instâncias APT com Rotação e sem Peso .............................................. 117 Tabela 5.16: Resultados nas Instâncias gcut com Rotação e sem Peso ............................................... 118 Tabela 5.17: Limites Superiores e Inferiores por Fases do X2D para o PCBGR ................................. 119 Tabela 5.18: Limites Superiores e Inferiores por Fases do X2D para o PCBGR Rotacionado .......... 119 Tabela 6.1: Resultados do GCH2D com Padrões de Corte Residuais RG2Da ....................................... 124 Tabela 6.2: Resultados do GCH2Dr com Padrões de Corte Residuais RG2Dar ...................................... 124

LISTA DE FIGURAS

Figura 1.1: Problema de Corte de Estoque Bidimensional Guilhotinado ............................................. 13 Figura 2.1: Estrutura dos Problemas de Corte e Empacotamento ......................................................... 20 Figura 2.2: Padrões de Corte Bidimensionais Ortogonais .................................................................... 24 Figura 3.1: Itens Regulares e Irregulares .............................................................................................. 28 Figura 3.2: Corte Guilhotinado Ortogonal ............................................................................................ 29 Figura 3.3: Cortes Guilhotinados em Dois Estágios ............................................................................. 29 Figura 4.1: Cortes Guilhotinados e Faixas Guilhotinas ........................................................................ 47 Figura 4.2: Faixas Guilhotinas Horizontais e Verticais ........................................................................ 48 Figura 4.3: Padrão de Corte para o PCBGR .......................................................................................... 49 Figura 4.4: Geração de Faixas Guilhotinas Horizontais e Verticais com Algoritmo G2D ..................... 54 Figura 4.5: Geração de Faixas Guilhotinas Horizontais e Verticais com Algoritmo G2D ..................... 55 Figura 4.6: Padrão de Corte Ótimo da Instância CU2 com Repetição de Faixas Homogêneas ............ 58 Figura 4.7: Faixas Guilhotinas Horizontais e Verticais com Melhoria A ............................................. 59 Figura 4.8: Padrão de Corte Ótimo da Instância OF1 com Melhorias M e A ....................................... 62 Figura 4.9: Padrão de Corte Ótimo da Instância ChW1 com Algoritmo G2Dv ...................................... 64 Figura 4.10: Faixas Guilhotinas Horizontais e Reaproveitamento de Dentes ....................................... 66 Figura 4.11: Faixas Guilhotinas Verticais e Reaproveitamento de Dentes ........................................... 67 Figura 4.12: Padrão de Corte com Reaproveitamento de Dentes .......................................................... 70 Figura 4.13: Padrão de Corte gcut13 com Reaproveitamento de Dentes e LRF ................................... 71 Figura 4.14: Padrões de Corte APT33 com Algoritmo RG2D ............................................................... 85 Figura 5.1: Padrões de Corte Inviáveis da Instância CW4 com Algoritmo X ...................................... 94 Figura 5.2: Padrão de Corte Ótimo da Instância CW4 com Algoritmo X2 .......................................... 99

LISTA DE QUADROS

Quadro 2.1: Nomenclatura da Tipologia ............................................................................................... 26 Quadro 2.2: Tipologia de Alguns Problemas ........................................................................................ 27 Quadro 3.1: Artigos Revisados do Problema de Corte de Estoque ....................................................... 41 Quadro 3.2: Artigos Revisados do Problema de Corte Bidimensional ................................................. 42

SUMÁRIO

1 INTRODUÇÃO ................................................................................................................... 12

2 TIPOLOGIA DOS PROBLEMAS DE CORTE E EMPACOTAMENTO .................... 19 2.1 DIMENSIONALIDADE .................................................................................................... 20 2.2 MEDIDAS QUANTITATIVAS ........................................................................................ 21 2.3 FORMATO DAS FIGURAS ............................................................................................. 21 2.4 SORTIMENTO .................................................................................................................. 22 2.5 DISPONIBILIDADE ......................................................................................................... 22 2.6 RESTRIÇÕES DE PADRÃO ............................................................................................ 23 2.7 RESTRIÇÕES DE ALOCAÇÃO ....................................................................................... 24 2.8 OBJETIVOS ....................................................................................................................... 25 2.9 ESTADO DA INFORMAÇÃO E VARIABILIDADE ...................................................... 25 2.10 NOMENCLATURA DE DYCKHOFF ............................................................................ 25

3 PROBLEMAS DE CORTE BIDIMENSIONAL .............................................................. 28 3.1 PROBLEMA DE CORTE DE ESTOQUE BIDIMENSIONAL GUILHOTINADO ........ 30 3.2 PROBLEMA DE CORTE BIDIMENSIONAL GUILHOTINADO RESTRITO ............. 32 3.3 REVISÃO BIBLIOGRÁFICA ........................................................................................... 33

4 AMPLIAÇÕES DO ALGORITMO G2D PARA O PCBGR ............................................ 43 4.1 METAHEURÍSTICA GRASP ........................................................................................... 43 4.1.1 Fase de Construção da GRASP .................................................................................... 44 4.1.2 Fase de Melhoria da GRASP ........................................................................................ 45 4.1.3 GRASP Reativo ............................................................................................................. 46 4.2 ALGORITMO G2D ORIGINAL ......................................................................................... 46 4.2.1 Fundamentos para Implementação do G2D ................................................................. 47 4.2.2 Fase de Construção das Faixas no Algoritmo G2D ...................................................... 50 4.2.3 Fase de Melhoria das Faixas no Algoritmo G2D .......................................................... 51 4.2.4 Geração de Padrão de Corte no Algoritmo G2D ......................................................... 53 4.2.5 Algoritmo G2D ................................................................................................................ 56 4.3 ALGORITMOS G2Da E G2Dv ............................................................................................. 57 4.3.1 Parâmetro φ e Repetição de Faixas Homogêneas ....................................................... 58 4.3.2 Movimento de Melhoria A ............................................................................................ 59 4.3.2 Pseudocódigo do Algoritmo G2Da ................................................................................. 62 4.3.3 Lista Restrita de Candidatos do Algoritmo G2Dv ........................................................ 63 4.4 ALGORITMOS G2D REATIVOS ...................................................................................... 64 4.4.1 Parâmetro δ e Dentes nas Faixas Guilhotinas ........................................................... 66 4.4.2 Parâmetro ψ e Lista Restrita de Faixas ...................................................................... 70 4.4.3 Pseudocódigo Genérico do Algoritmo RG2D ............................................................... 72 4.5 RESULTADOS COMPUTACIONAIS ............................................................................. 74

5 ALGORITMO PRIMAL-DUAL PARA O PCBGR ........................................................ 86 5.1 PROGRAMAÇÃO DINÂMICA PARA O PCBGI ........................................................... 86 5.1.1 Programação Dinâmica para Discretização ................................................................ 87 5.1.2 Algoritmo Dynamic Programming .............................................................................. 87 5.2 PROGRAMAÇÃO DINÂMICA PARA O PCBGR ......................................................... 89 5.2.1 Relaxação do Espaço de Estados da Programação Dinâmica .................................. 90 5.3 LIMITES SUPERIORES PARA O PCBGR POR PROGRAMAÇÃO DINÂMICA E INTEIRA .................................................................................................................................. 92 5.3.1 Algoritmo X .................................................................................................................... 92

5.3.2 Algoritmo X2 .................................................................................................................. 96 5.4 LIMITES INFERIORES PARA O PCBGR POR GRASP, PROGRAMAÇÃO DINÂMICA E INTEIRA ......................................................................................................... 99 5.4.1 Heurística X2H ............................................................................................................ 100 5.4.2 Múltiplos Padrões na Matriz da Programação Dinâmica ....................................... 102 5.4.3 Heurística de Viabilização .......................................................................................... 102 5.5 ALGORITMO X2D ........................................................................................................... 103 5.6 RESULTADOS COMPUTACIONAIS ........................................................................... 104

6 ALGORITMOS GERAÇÃO DE COLUNAS PARA O PCEBG .................................. 120 6.1 ALGORITMOS GCH2D E GCH2Dr .................................................................................. 120 6.2 RESULTADOS COMPUTACIONAIS ........................................................................... 122

7 CONCLUSÕES E TRABALHOS FUTUROS ................................................................ 125

REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................... 129

ANEXO: INSTÂNCIAS DOS PADRÕES DE CORTE ILUSTRADOS ......................... 133

12

1 INTRODUÇÃO

O planejamento operacional de ações que consistem na transformação de materiais

em produtos semiacabados ou finais, não somente evidenciam a tecnologia de processos como

também destacam a produtividade, utilizando de forma inteligente os recursos da produção.

Nas empresas atuantes em setores produtivos que consideram o beneficiamento de materiais,

através do corte realizado em madeiras, metais, vidros, rochas ornamentais, tecidos entre

outras matérias-primas, cujas sobras praticamente não são reaproveitadas, o objetivo de

minimizar o desperdício nestas transformações resultariam em considerável melhoria e

eficiência dos processos, promovendo estimável redução nos custos e, principalmente,

agregando diferencial competitivo a esses produtos.

Nesse contexto, é importante ressaltar que as empresas bem sucedidas consideram

imprescindível um rigoroso controle de seus custos. As empresas que desejam aumentar sua

competitividade no mercado devem ter como objetivos a alta qualidade e a eficiência, pois um

processo não otimizado pode significar altos custos. Diminuir o desperdício de matéria prima

no processo produtivo reduz os custos e, consequentemente, esses produtos podem chegar ao

mercado com um preço menor, aumentando o volume de vendas, a receita da empresa e a

satisfação do consumidor. Ressaltando ainda que os custos de uma operação podem ser

reduzidos melhorando a eficiência do processo. Assim, a realização de suas atividades de

forma apropriada, no menor custo possível, proporciona a uma empresa considerável

vantagem competitiva.

Dos problemas de Engenharia de Produção que podem ser representados através de

um modelo de otimização, o trabalho destaca alguns dos Problemas de Corte e

Empacotamento, como são conhecidos na literatura, evidenciando variantes dos clássicos

Problema de Corte (Cutting Problem) e Problema de Corte de Estoque (Cutting Stock

Problem). Restringido a cortes ortogonais do tipo guilhotina, possivelmente realizados por

lâminas ou lasers, para obtenção de produtos retangulares a partir de materiais com o mesmo

formato, o Problema de Corte Bidimensional Guilhotinado Restrito (PCBGR) e o Problema

de Corte de Estoque Bidimensional Guilhotinado (PCEBG) apresentam-se como objeto de

estudo no presente trabalho.

Nessa ordem, um problema com relativo destaque na literatura é o Problema de

Corte Bidimensional (PCB) que busca determinar um único padrão de corte, com duas

dimensões relevantes, comprimento e largura, que minimize a perda de matéria prima gerada

ou maximize o lucro total, com o corte dos itens, dá as características necessárias para

13

identificar as variantes do PCB. Aos itens, atribui-se um valor de utilidade que pode ser a

medida de sua área (PCB sem peso) ou estar relacionado à sua importância em presença aos

outros itens (PCB com peso). Uma rotação de 90º nos itens pode ser aceita (PCB com

rotação) ou proibida (PCB sem rotação). Os cortes ortogonais podem ser guilhotinados e gerar

dois novos retângulos (PCBG) ou não guilhotinados (PCBNG). A quantidade de cada item

produzido a partir de cortes guilhotina pode ser restrita (PCBGR) ou ilimitada (PCBGI), e

abordagens para estas variantes também são evidenciadas neste trabalho. O número de

estágios no padrão de corte está relacionado à quantidade de mudanças permitidas na direção

dos cortes guilhotina, ou seja, pode-se admitir apenas k rotações de 90º nas direções destes

cortes (k-estagiado) ou não restringir esta quantidade (não estagiado). A Figura 1.1 destaca

dois padrões de corte distintos com dois e quatro estágios, respectivamente, e indicando a

sequência dos k estágios por Gk.

FIGURA 1.1 – Problema de Corte de Estoque Bidimensional Guilhotinado

Já o PCEBG consiste em determinar como se deve cortar um conjunto de peças

retangulares (Objetos) em quantidade suficiente, a partir de cortes ortogonais a um dos lados

dessas peças, com o intuito de produzir certa quantidade de peças retangulares menores

(Itens), utilizando a menor quantidade possível desses objetos. Com sua grande aplicabilidade

em variados setores de produção, anteriormente exemplificados, uma solução ótima para este

problema apresentaria quais padrões bidimensionais, produzidos a partir de cortes com

guilhotina, devem ser repetidos o mínimo de vezes para atender uma demanda, conforme

ilustrado na Figura 1.1.

Na tipologia apresentada por Dyckhoff (1990) para os Problemas de Corte e

Empacotamento, o PCBGR é apontado pela quádrupla 2/B/O/R, que determina ser um

Itens a Produzir Padrão de Corte 1 Padrão de Corte 2

Perda

14

problema da classe bidimensional (2), (B) determina a alocação de todos os objetos e uma

parte dos itens, (O) delimita o problema a um objeto e relativamente poucos itens, com várias

cópias de cada item (R). Já o PCEBG é indicado pela quádrupla ordenada 2/V/I/R, com todos

os itens sendo designados a uma seleção de objetos (V) e estes possuindo formatos idênticos

(I). Uma nova tipologia, aprimorada a partir desta por Wäscher et al. (2007), na qual os

Problemas de Corte e Empacotamento são caracterizados por dimensionalidade, tipo de

alocação, variedade dos itens, variedade dos objetos e forma dos itens, também aparece em

destaque na literatura e atribui aos respectivos problemas supracitados a seguinte

classificação: 2-d Retangular SLOPP (Two-dimensional Rectangular Single Large Object

Placement Problem) e 2-d Retangular SSSCSP (Two-dimensional Rectangular Single Stock-

Size Cutting Stock Problem).

Do ponto de vista prático, o PCBGR e o PCEBG estão presentes no cotidiano das

várias empresas do setor de beneficiamento de rochas ornamentais, por exemplo, as

encontradas nas regiões Norte e Noroeste Fluminense. As marmorarias, como são conhecidas

essas empresas, produzem peças sob encomenda para a construção civil, cortando-se placas

de mármore ou granito em pedaços menores. Os cortes nessas placas podem ser arranjados de

várias maneiras e, geralmente, produzem retalhos de matéria prima, provenientes dos pedaços

que sobram, após o corte das peças desejadas. Nos casos em que a otimização das placas não

se faz presente, os retalhos, sobras de matéria-prima que dificilmente são reaproveitadas,

acabam influenciando o preço do produto final, devido ao valor irrelevante destes no

mercado. Como em muitas dessas empresas, a forma de se determinar este arranjo não é

fundamentada em métodos científicos, e sim por métodos, que, baseados apenas na

experiência, acabam produzindo retalhos em quantidades indesejáveis, refletindo diretamente

no custo final do produto. Portanto, minimizar a perda de matéria prima, ou maximizar o seu

aproveitamento, com a melhoria e a eficiência das atividades de corte, pode resultar em

economias substanciais vindos a ser um importante diferencial de competitividade para as

empresas deste setor.

A fácil compreensão destes problemas supracitados esconde a sua real complexidade

quando o objetivo é obter soluções rápidas, que atendam às necessidades cotidianas dos

setores produtivos em tempo real. De uma forma geral, os Problemas de Corte pertencem à

classe de problemas denominada NP-Difícil (GAREY; JOHSON, 1979), em que não é

interessante o uso exclusivo de algoritmos exatos para problemas de médio e grande porte.

Isto significa que a determinação da solução ótima para todas essas variantes do PCB, assim

como o PCEBG correspondente, está relacionada a um processo de otimização combinatória

15

intratável do ponto de vista computacional, devido ao grande número de padrões de corte

possíveis. Nestes casos, os métodos heurísticos e híbridos são bastante considerados,

constituindo-se uma alternativa válida para os respectivos problemas.

Uma abordagem clássica para o tratamento dos Problemas de Corte de Estoque

(PCE) em geral, é a Geração de Colunas (GC), introduzida por Gilmore e Gomory (1961,

1963, 1965). Para determinar as colunas interessantes no Problema Linear Mestre (PL

Mestre), a GC exige a solução dos chamados problemas de corte com peso (subproblema de

apreçamento), que buscam por um padrão de corte que maximize o lucro total dos itens

produzidos nesse padrão. Na literatura, as técnicas baseadas em GC têm alcançado bons

resultados no PCEBG k-estagiado, onde os subproblemas de apreçamento são do tipo PCBGR

k-estagiado ou PCBGI k-estagiado. Neste caso, abordagens utilizando híbridos com GC e

heurísticas, ou mesmo modelos completos de Programação Inteira Mista (PIM), podem ser

conferidas em Cintra et al. (2008), Silva et al. (2010) e Furini et al.(2012).

Entretanto, sabe-se que o PCBGR é fortemente NP-Difícil (HIFI, 2004b) e o não

estagiado é mais difícil de resolver de forma exata do que o PCBGR k-estagiado ou o PCBGI

não estagiado. Existem relativamente poucos trabalhos propondo métodos exatos para a

resolução do PCBGR, como os algoritmos exatos propostos por Christofides e Whitlock

(1977), Christofides e Hadjiconstantinou (1995), Hifi (1997a), Cung et al. (2000) e

Dolatabadi et al. (2012). Algumas abordagens utilizam também Programação Inteira Mista

(PIM) como apresentado em Furini et al. (2016). Porém, todos estes métodos ainda

apresentam tempos proibitivos nas instâncias consideradas de médio e grande porte.

Consequentemente, a utilização de métodos heurísticos e híbridos aparece com uma

alternativa plausível e algumas dessas abordagens podem ser conferidas nos trabalhos de

Alvarez-Valdés et al. (2002a), Hifi (2004b), Morabito e Pureza (2010).

Defronte a esta dificuldade, o trabalho apresenta um estudo sobre a aplicação da

técnica Reactive Greedy Randomized Adaptive Search Procedure (GRASP Reativo),

juntamente a algoritmos baseados em Programação Dinâmica (PD) e Programação Inteira

(PI), para o PCBGR. Com a mesma incumbência, propõe-se reunir as técnicas GC, PD e a

metaheurística GRASP na construção de um algoritmo para tratar do PCEBG.

Apresentado inicialmente em (VELASCO et al., 2008), as novas ampliações do

algoritmo GRASP-2D (G2D) são inspiradas nos conceitos GRASP Reativo (PRAIS;

RIBEIRO, 2000) para determinação do melhor parâmetro α. Entretanto, a fase de ajustes

nesses novos algoritmos reativos vai incorporar o parâmetro ψ, associado à escolha da nova

faixa que compõe um padrão de corte. Sendo as ampliações reativas denominadas RG2Da e

16

RG2Dv para as variantes sem peso e com peso do PCBGR, estas também passam a considerar

os casos sem rotação e com rotação via RG2Dar e RG2Dvr. Além disso, são realizados melhorias

nas faixas que consideram inclusive o reaproveitamento dos subretângulos categorizados

como perdas e chamados de dentes. Para fins de validação, os resultados para o caso sem

rotação são comparados com os apresentados nos trabalhos de Alvarez-Valdés et al. (2002a),

Morabito e Pureza (2010), e Dolatabadi et al. (2012).

Sabendo que Christofides e Hadjiconstantinou (1995) propuseram uma PD com

relaxação do espaço de estados para obter de limites superiores ZUB fortes para o PCBGR,

onde a qualidade desse limite depende de um vetor de pesos q, com dimensão dada pelo total

de itens distintos. Para ajustar tais pesos, criaram um algoritmo inspirado no método do

subgradiente para relaxação lagrangeana. O presente trabalho propõe o algoritmo dual X, em

que os pesos são calculados por PI. Esse algoritmo é provadamente ótimo no sentido de

sempre obter os pesos que minimizam o limite superior final alcançado. É proposta também

uma generalização da relaxação do espaço de estados que utiliza pesos bidimensionais, para

melhorar ainda mais a qualidade dos limites superiores, e o algoritmo dual X2 é apresentado

para esse ajuste ótimo dos pesos. O algoritmo primal X2H é outra proposta que consiste em

uma heurística primal baseada na adaptação de X2. Assim como os novos algoritmos RG2D,

X2H tem a finalidade de obter um padrão de corte viável que melhore o limite inferior ZLB.

Admitindo a possibilidade de que a substituição de itens que apresentam quantidade acima da

demanda por outros ainda não produzidos pode gerar uma solução de maior valor, é

apresentada uma heurística de viabilização do padrão de corte. Esse processo de viabilização

pode ser realizado nos padrões ótimos e subótimos da PD relaxada para algum vetor de pesos

q. Finalmente, o método composto pelos algoritmos X, X2 RG2D e X2H é proposto para

resolução do PCBGR, nas variantes que se diferenciam pelo valor de utilidade dos itens e a

questão de sua rotação. Chamado de X2D, este algoritmo é capaz de fornecer certificado de

otimalidade a solução de valor ZLB igual a ZUB. Este algoritmo X2D é testado em 513

instâncias que se dividem nas variantes sem rotação e seus respectivos resultados são

comparados com os algoritmos DP_AOG e A1, propostos por Morabito e Pureza (2010) e

Dolatabadi et al. (2012). No caso rotacionado, é importante ressaltar que ainda não há

resultados disponíveis na literatura para comparação com o algoritmo X2D.

A aplicação conjugada da técnica GC para o PCEBG, com um algoritmo de

Programação Dinâmica para o PCBGI e a versão reativa RG2D para o PCBGR, constitui o

algoritmo híbrido GCH2D, proposto por Velasco e Uchoa (2015). Sabendo que o algoritmo

denominado DP, incialmente apresentado por Beasley (1985) para o PCBGI, foi reestruturado

17

para o subproblema da GC proposta por Cintra et al. (2008) e caso a solução ótima do PL

Mestre não seja inteira, basicamente o processo consiste em utilizar o RG2D para resolver o

problema residual como um PCBGR até que a demanda seja atendida. Para avaliar o

desempenho dos algoritmos híbridos GCH2D e GCH2Dr, nos casos sem e com rotação, foram

realizados testes em 24 instâncias do PCEBG e comparados com os algoritmos CG, CGP,

CGR e CGRP apresentados em Cintra et al. (2008).

Este trabalho está dividido em 7 capítulos. Além do Capítulo 1 introdutório, duas

estruturas lógicas, compreendendo as características essenciais para a classificação dos

Problemas de Corte e Empacotamento, segundo Dyckhoff (1990) e Wäscher et al.(2007), são

descritas no Capítulo 2.

No Capítulo 3, são apresentadas as definições dos Problemas de Corte Bidimensional

que caracterizam o PCEBG e o PCBGR. Ainda neste capítulo, são mostradas as dificuldades

envolvidas na modelagem destes problemas e uma introdução conceitual do método Geração

de Colunas, concluindo com uma revisão bibliográfica que aborda ambos.

No Capítulo 4, é apresentada a implementação computacional das ampliações do

algoritmo G2D que culminaram nas suas versões reativas para o PCBGR, com e sem peso ou

rotação. Este capítulo inicia-se com os procedimentos característicos da metodologia GRASP

e as definições necessárias na arquitetura dos procedimentos que dão origem as faixas

horizontais e verticais do padrão de corte guilhotinado. Os novos parâmetros e estratégias de

ajuste, definição de uma Lista Restrita de Faixas e suas atualizações e movimentos de

melhoria que incluem o reaproveitamento de dentes nas faixas guilhotinas são apresentados

com ênfase no decorrer desse Capítulo. Por último, é descrito o pseudocódigo geral do

algoritmo RG2D e confrontados os respectivos resultados computacionais com algoritmos

reconhecidos da literatura.

Inicialmente no Capítulo 5, é descrito o algoritmo DP para o PCBGI apresentado em

(CINTRA et al., 2008), incluindo o algoritmo DDP que retorna um conjunto de pontos de

discretização de um padrão canônico. Também é dada a devida ênfase a relaxação do espaço

de estados proposta por Christofides e Hadjiconstantinou (1995). Em seguida, os algoritmos

duais X e X2 são apresentados de forma a obter limites superiores sempre mais fortes, com os

respectivos vetores de pesos da PD relaxada sendo calculados por Programação Inteira.

Descreve-se então, a heurística primal X2H e a possibilidade de atualizar os limites inferiores

com os respectivos algoritmos RG2D, nos múltiplos padrões subótimos da PD ou através de

uma heurística de viabilização aplicada nos padrões inviáveis gerados por X, X2 e X2H.

Sendo o algoritmo X2D uma composição dos algoritmos supracitados, este é apresentado com

18

destaque por ter a capacidade de garantir certificação de otimalidade para soluções do

PCBGR, nas variantes com e sem rotação. Ao final desse Capítulo, são expostos os testes

computacionais e suas devidas comparações para validação do algoritmo proposto.

O Capítulo 6 apresenta o desenvolvimento dos algoritmos híbridos GCH2D e GCH2Dr,

para o PCEBG com e sem rotação. O Capítulo inicia-se com a apresentação dos fundamentos

necessários na arquitetura desses algoritmos, seguido de um pseudocódigo genérico e dos

resultados computacionais dos algoritmos relacionados.

Finalmente, no Capítulo 7, são apresentadas algumas considerações sobre as

contribuições adquiridas com a utilização dos algoritmos RG2D, X2D e GCH2D propostos para

otimização dos respectivos PCBGR e PCEBG, além de expor novas sugestões para

continuidade da pesquisa.

19

2 TIPOLOGIA DOS PROBLEMAS DE CORTE E EMPACOTAMENTO

O Problema de Corte consiste em determinar a melhor maneira de produzir um

conjunto de peças menores (denominadas itens) efetuando cortes em peças maiores

(denominadas objetos). Enquanto, o Problema de Empacotamento consiste basicamente em

determinar o melhor arranjo de um conjunto de itens dentro de objetos. Empacotar itens

dentro de objetos também pode ser visto como cortes de espaços, sendo estes espaços

ocupados por itens ou considerados perdas. De forma recíproca, o problema de corte pode ser

encarado como empacotamento de espaços ocupados por itens em espaços ocupados por

objetos (DYCKHOFF, 1990).

Os Problemas de Corte e Empacotamento, tais como corte de barras de ferro e

barrotes de madeira na construção civil, corte de placas de granito nas marmorarias, corte de

espumas para colchões e empacotamento de caixas em contêineres estão centrados em objetos

e itens definidos por uma, duas ou três dimensões do espaço Euclidiano. De forma análoga,

problemas desta categoria podem ter objetos e itens com dimensões abstratas, como por

exemplo, o balanceamento de uma linha de montagem com dimensões temporais. Neste caso,

o estoque de objetos é definido pelas estações de trabalho com intervalos de tempo fixados e a

lista de itens é dada por tarefas específicas com durações que devem ser determinadas. Exceto

pela restrição que impõe um ordenamento nas tarefas a cumprir, a estrutura lógica é a mesma

encontrada nos problemas de empacotamento.

Assim como em Dyckhoff (1990), a Figura 2.1 exibe uma estrutura dos Problemas de

Corte e Empacotamento, evidenciando a questão das dimensões espaciais e abstratas. E

também, nos exemplos citados são apresentadas algumas das aplicações para os problemas

dessa natureza.

Em vista da multiplicidade dos Problemas de Corte e Empacotamento nos setores

produtivos e da importância desses problemas no planejamento da produção de algumas

empresas há um incessante interesse de administradores, economistas, engenheiros,

matemáticos, entre outros pesquisadores, em buscar soluções para esses problemas. Com a

finalidade de classificar os Problemas de Corte e Empacotamento, identificar características

comuns e concentrar pesquisas futuras em problemas de tipos específicos, Dyckhoff (1990)

sugeriu em seu artigo uma nomenclatura baseada em uma estrutura lógica. A notoriedade

deste trabalho culmina na publicação do livro Cutting and Packing in Production and

Distribution, por Dyckhoff e Finke (1992), relacionando esta estrutura lógica junto à realidade

dos Problemas de Corte e Empacotamento.

20

FIGURA 2.1 – Estrutura dos Problemas de Corte e Empacotamento.

Esta estrutura lógica inclui características suficientes para especificar o tipo de um

problema de corte e empacotamento. A seguir, uma precisa descrição dessas características é

apresentada.

2.1 DIMENSIONALIDADE

A dimensionalidade é a característica mais importante, já que determina o número de

dimensões relevantes, em objetos e itens, na definição de um padrão para o problema. Um

padrão corresponde a uma disposição de itens em objetos. Quanto à dimensionalidade, um

problema pode ser classificado como:

� Unidimensional;

� Bidimensional;

� Tridimensional;

� Multidimensional;

� n½ - dimensional.

O problema é unidimensional quando uma única dimensão é relevante para a

definição de um padrão. Por exemplo, na indústria de papel, bobinas de comprimento

padronizado devem ser cortadas em rolos de vários comprimentos pré-determinados. O

problema mencionado anteriormente de balanceamento de uma linha de montagem é um

problema unidimensional.

21

Quando duas dimensões são relevantes na determinação de um padrão, o problema é

bidimensional. No corte de placas de granito em peças menores, nas empresas do setor de

beneficiamento de rochas ornamentais (marmorarias), a largura e o comprimento são as

medidas relevantes. A Figura 1.1 ilustra padrões de corte para o problema bidimensional.

No corte de colchões a partir de blocos de espumas ou no empacotamento de caixas

em contêineres, a largura, o comprimento e a altura de objetos e itens são imprescindíveis na

resolução do problema. Este problema é dito tridimensional devido às três dimensões

relevantes na definição de um padrão.

Se o número de dimensões relevantes para definição de um padrão for maior que

três, então este problema é multidimensional. Um exemplo de problema de quatro dimensões

seria estocar caixas num contêiner por períodos de tempo fixados e ininterruptos. Neste caso,

junto ao problema de empacotamento tridimensional, apresenta-se uma quarta dimensão, o

tempo de permanência de cada caixa.

Os problemas n½ - dimensionais têm n+1 dimensões relevantes na definição de um

padrão, sendo n dimensões fixas e uma variável. No cotidiano das gráficas, o corte de lona em

rolos, para produção de cartazes de dimensões fixas, é um exemplo de problema 1,5

dimensional. Um padrão de corte para este problema, que apresenta 1+1 dimensões

relevantes, é definido em um tecido de largura fixa e comprimento variável, ou seja, com

comprimento suficiente para atender a demanda.

2.2 MEDIDAS QUANTITATIVAS

Os valores atribuídos às variáveis que indicam o número de objetos e itens em uma

solução podem ser:

� Discretos;

� Contínuos.

Em problemas com dimensões bem definidas, como o caso bidimensional, as

variáveis estão condicionadas a assumir valores discretos. Enquanto nos problemas com uma

dimensão variável há variáveis assumindo valores contínuos.

2.3 FORMATO DAS FIGURAS

Outra característica a ser observada é o formato das figuras de objetos e itens

envolvidos no problema. Seja uma figura distinguida por:

� Forma;

� Tamanho;

� Orientação.

22

Figuras de mesma forma podem diferir em tamanho ou orientação no espaço

relevante. Como por exemplo, no corte de vergalhões para armadura na construção civil

(VIEIRA NETO et al., 2013), onde objetos e itens apresentam comprimentos variados, ou no

corte de peças retangulares de vidro, onde é permitida uma rotação de 90 graus em objetos e

itens. Em problemas com mais dimensões relevantes, as figuras possuem formas regulares,

especialmente retangulares ou em blocos, ou irregulares, no caso destas serem assimétricas ou

não convexas tipicamente encontradas nas indústrias têxteis e de calçados.

O tamanho de uma figura pode ser determinado pela medida de seu comprimento,

área ou volume. Este consiste em um importante aspecto, pois o tamanho dos itens em relação

aos objetos pode impor dificuldades na resolução de um problema específico. Em um

problema bidimensional, o tamanho das figuras pode ser definido pelas suas respectivas áreas.

De acordo com o problema, a posição ou orientação de itens em relação a objetos

pode ser fixa, admitindo-se apenas 90 graus de rotação ou permitindo-se qualquer orientação.

Neste trabalho, também se trata a hipótese de um item qualquer poder ser rotacionado em 90

graus e as respectivas figuras rotacionadas ou não rotacionadas serem consideradas idênticas.

Sob essa hipótese, um item retangular de comprimento x e largura y não difere de outro item

que possui comprimento y e largura x.

2.4 SORTIMENTO

Tanto o formato quanto a diversidade das figuras de objetos e itens são fundamentais

na caracterização de um problema. Por exemplo, a indústria de circuito impresso convive com

o problema de cortar chapas retangulares (objetos com formatos idênticos) de fibra de vidro

para fabricação de placas (muitos itens com formatos distintos) de circuito impresso.

2.5 DISPONIBILIDADE

Com respeito à disponibilidade de objetos e itens são considerados três fatores:

� Limites, superior e inferior, em sua quantidade;

� Sequência ou ordem;

� Data de utilização.

De acordo com o problema, a quantidade de objetos e itens pode ser restrita ou

irrestrita, isto é, limitada ou ilimitada, respectivamente. Em alguns problemas, os padrões são

determinados em uma quantidade limitada de objetos com itens em quantidades ilimitadas. Já

em outros, deseja-se obter padrões que produzam itens em quantidades limitadas ou não, a

partir de uma indefinida quantidade de objetos. Por exemplo, no cotidiano das empresas do

23

setor vidraceiro, uma quantidade suficiente de chapas é utilizada na produção de uma

determinada quantidade de peças.

Nas metalúrgicas, a necessidade de se respeitar certa ordem para objetos e itens,

quanto ao tempo na definição de um padrão, é observado quando barras incandescentes

cobertas de aço são produzidas, em um processo sequencial e sem retardos.

2.6 RESTRIÇÕES DE PADRÃO

Basicamente, as restrições de padrão estão ligadas às características geométricas e

operacionais do problema. Estas restrições são esclarecidas e distinguidas em quatro

importantes grupos descritos a seguir.

i) Os espaços entre os itens em um padrão são extremamente importantes em alguns

casos, como por exemplo, no corte de placas de vidro, onde estes espaços resultam em perda

de matéria-prima. Outra situação relevante em processos produtivos está relacionada ao

desperdício do objeto, ocasionado por um instrumento cortante. Neste caso, geralmente, esta

espessura está adicionada às dimensões dos itens encontrados no padrão em questão.

ii) A posição dos itens, em relação aos mesmos, ou em relação ao objeto, tem de ser

levada em consideração, como no caso do carregamento de produtos frágeis.

iii) Podem existir restrições quanto ao número de itens em um padrão, como por

exemplo, no empacotamento de bombons de chocolate em caixas para comercialização, onde

a quantidade de itens distintos é limitada.

iv) O tipo de corte executado e o número de cortes permitidos são essenciais nos

problemas em que objetos e itens são retangulares ou em forma de blocos. Em um problema

bidimensional, cujo padrão é definido através de cortes guilhotinados e ortogonais, a sua

complexidade depende do número de mudanças nas direções de corte (estágios) como

também do número de cortes paralelos por estágio.

Pode haver padrões resultantes de cortes não ortogonais e guilhotinados, como

também, de cortes ortogonais e não guilhotinados. A Figura 2.2 destaca dois tipos de padrões

resultantes de cortes ortogonais, com cinco itens em ambos, sendo o padrão de corte

guilhotinado configurado com cinco estágios. Ainda nessa figura, os k estágios são indicados

por Gk e consideram uma sequência de rotações de 90º na direção dos cortes, paralelas aos

lados do objeto.

24

FIGURA 2.2 – Padrões de Corte Bidimensionais Ortogonais.

2.7 RESTRIÇÕES DE ALOCAÇÃO

Em relação à designação de itens para objetos, são evidenciadas as seguintes

restrições:

� Tipo de alocação;

� Número de estágios;

� Número, frequência ou sequência dos padrões;

� Dinâmica de alocação.

O tipo de alocação é uma propriedade fundamental na classificação de um problema

de corte e empacotamento. O corte de objetos para produção de itens pode ser visto como uma

alocação de itens em objetos, onde duas categorias de alocação se destacam na distinção de

um problema:

i) Típica dos problemas clássicos de corte e empacotamento, a designação de um

conjunto de itens a um subconjunto de objetos.

ii) Observada no carregamento de pallet, quando um subconjunto de itens é

designado a um conjunto de objetos.

O número de estágios de um problema está relacionado com a quantidade de passos

necessários para definição de um padrão. No problema bidimensional, um padrão pode ser

obtido por cortes ou empacotamentos, estagiados (com um número pré-determinado de

estágios) ou não estagiados (sem limitação de estágios).

Nos processos produtivos, tanto as conexões estabelecidas entre as etapas, como as

tecnologias envolvidas nos processos de alocação podem impor restrições relacionadas à

Padrão Ortogonal Não Guilhotinado

Padrão Ortogonal Guilhotinado

Perda

25

sequência ou ordem de padrões. Também podem existir limitações quanto ao número de

padrões de mesmo tipo ou de tipos distintos.

A alocação de itens em objetos pode ser de natureza dinâmica ou estática. Na

alocação estática, se os objetos e itens são previamente conhecidos, o processo é dito off-line,

caso contrário o processo é on-line. Já no processo dinâmico, em função da não

disponibilidade de objetos e itens em um mesmo período, as alocações seguem uma regra pré-

estabelecida que permita a realocação dos itens em objetos.

2.8 OBJETIVOS

Um objetivo significa usar um critério a ser maximizado ou minimizado para

expressar a dimensão da eficácia obtida na solução de um problema. Alguns critérios a serem

satisfeitos em Problemas de Corte e Empacotamento são listados abaixo.

i) Minimizar a perda de material nos processos de corte ou empacotamento.

ii) Minimizar os custos envolvidos no processo produtivo, como por exemplo,

despesas com armazenagem.

iii) Maximizar os lucros com a eficácia e a qualidade dos processos.

2.9 ESTADO DA INFORMAÇÃO E VARIABILIDADE

Determinar se os dados de um problema são determinísticos ou estocásticos, ou

ainda, se estes são exatos ou podem ser variáveis, são características relevantes não apenas

para os Problemas de Corte e Empacotamento. Por exemplo, uma demanda de determinados

itens ordenada em um pedido geralmente possui dados determinísticos podendo ser variável

caso certas mudanças sejam admitidas pelos clientes.

2.10 NOMENCLATURA DE DYCKHOFF

As características dimensionalidade, sortimento e restrições de alocação constituem

uma base para elaboração de uma nomenclatura que associe os Problemas de Corte e

Empacotamento afins, além de influenciarem diretamente na escolha e na complexidade do

método de solução. A tipologia de um problema é indicada através da quádrupla,

dimensionalidade/ tipo de alocação/ sortimento de objetos/ sortimento de itens, e cada

característica é subdividida em determinados tipos que são indicados por letras, conforme o

quadro 2.1 a seguir.

26

QUADRO 2.1 – Nomenclatura da Tipologia.

Dimensionalidade Tipo de Alocação

(1) Unidimensional

(2) Bidimensional

(3) Tridimensional

(N) N-dimensional, com N > 3

(B) Todos os objetos e uma seleção de itens

(V) Uma seleção de objetos e todos os itens

Sortimento de Objetos Sortimento de Itens

(O) Um objeto

(I) Objetos de formatos idênticos

(D) Objetos de formatos distintos

(F) Poucos itens de diferentes formatos

(M) Muitos itens de muitos formatos distintos

(R) Muitos itens de formatos distintos em relativa

quantidade

(C) Itens de formatos congruentes

Os agrupamentos formados por todos os tipos destas quatro características indicam

96 tipos distintos de Problemas de Corte e Empacotamento, onde cada agrupamento consta de

uma quadrúpla ordenada α/β/γ/δ, em que α representa o número de dimensões relevantes do

problema, β o tipo de alocação considerada com relação a objetos e itens, γ o sortimento dos

objetos envolvidos e δ o sortimento dos itens requisitados. Por exemplo, a notação 2/V/I/R é

utilizada para indicar o PCEBG, enfatizado neste trabalho, que é do tipo bidimensional (2),

com todos os itens sendo designados a uma seleção de objetos (V), objetos estes de formatos

idênticos (I) e itens de formatos distintos em relativa quantidade (R). No quadro 2.2 são

listados alguns dos clássicos da literatura atribuídos à classe dos Problemas de Corte e

Empacotamento, com as suas respectivas quadrúplas, como o PCBGR que é apontado pela

quádrupla 2/B/O/R, onde (B) determina a alocação de todos os objetos e uma parte dos itens e

(O) delimita o problema a um objeto.

É importante ressaltar, também, que uma nova tipologia, aprimorada a partir dessa

por Wäscher et al. (2007), onde os Problemas de Corte e Empacotamento são caracterizados

por dimensionalidade, tipo de alocação, variedade dos itens, variedade dos objetos e forma

dos itens. Segundo Wäscher et al. (2007), as modificações permitiram que cada problema

tivesse uma codificação única, de acordo com a sua modelagem e os respectivos métodos, e

atribui aos objetos deste estudo a seguinte classificação: 2-d Retangular SSSCSP (Two-

dimensional Rectangular Single Stock-Size Cutting Stock Problem) e 2-d Retangular SLOPP

(Two-dimensional Rectangular Single Large Object Placement Problem).

27

QUADRO 2.2 – Tipologia de alguns problemas.

Problema Tipo

Problema da mochila clássico 1/B/O/ Problema da mochila multidimensional /B/O/

Problema do carregamento de pallet 2/B/O/C

Problema do carregamento de veículos 1/V/I/F ou 1/V/I/F Problema do carregamento de contêiner 3/V/I/ ou 3/B/O/

Problema do bin packing clássico 1/V/I/M

Problema do bin packing dual 1/B/O/M

Problema do bin packing bidimensional 2/V/D/M

Problema do cutting stock clássico 1/V/I/R

Problema do cutting stock bidimensional 2/V/I/R

Problema do cutting stock generalizado 1/ / / , 2/ / / ou 3/ / / Problema do balanceamento de uma linha de montagem 1/V/I/M

Problema de alocação de memória 1/V/I/M

Problema de alocação de tarefas em multiprocessador 1/V/I/M

Problema de câmbio monetário 1/B/O/R

Problema de investimento financeiro em multiperíodos N/B/O/

28

3 PROBLEMAS DE CORTE BIDIMENSIONAL

Em diversos processos produtivos encontram-se atividades de corte de material, que

são efetuadas em objetos retangulares para atender a uma demanda de itens retangulares

menores, de maneira que o desperdício de material durante este processo seja minimizado.

Este problema caracteriza-se como bidimensional quando duas dimensões são fundamentais

na sua resolução, ou seja, a largura e o comprimento dos objetos e itens envolvidos no

processo são essenciais na definição de um padrão de corte.

A geração de padrões de corte para o problema bidimensional, envolvendo objeto e

itens que a presentam forma regular, isto é, de formato retangular, aparecem com relativo

destaque na literatura deste problema. Porém, em alguns casos, os itens podem ser irregulares,

ou seja, não apresentam formato retangular. A Figura 3.1 exibe alguns exemplos de contornos

de itens que possuem forma regular e irregular.

FIGURA 3.1 – Itens Regulares e Irregulares.

De acordo com a geometria dos itens envolvidos e as características operacionais do

problema, se os itens apresentam formato retangular, um padrão de corte pode ser obtido

através de cortes guilhotinados ou não guilhotinados. Esses padrões guilhotinados são

distinguidos em ortogonais e não ortogonais. Se um corte ao ser realizado em um objeto

retangular gerar outros dois retângulos, este é chamado de guilhotinado ortogonal, quando

não, é denominado de guilhotinado não ortogonal. A fim de delimitar o problema, os cortes

efetivados devem ser paralelos aos lados do retângulo, conforme é apresentado na Figura 3.2,

e um padrão de corte guilhotinado é aquele definido por série de cortes guilhotinados verticais

ou horizontais.

Forma Regular Forma Irregular

29

FIGURA 3.2 – Corte Guilhotinado Ortogonal.

Na utilização de cortes guilhotinados, estes ainda são classificados em:

� Cortes estagiados;

� Cortes não estagiados.

Os cortes são estagiados se houver restrições, provenientes das características

operacionais do problema, que limitam o número de estágios permitidos para determinação de

um padrão de corte. No entanto, se o número de estágios em um padrão de corte é irrelevante

na solução de um problema, os cortes são ditos não estagiados. A Figura 3.3 ilustra um

processo de execução de cortes guilhotinados, onde os cortes efetuados em uma única direção

definem um estágio e a cada mudança na direção dos cortes, um novo estágio é estabelecido.

FIGURA 3.3 – Cortes Guilhotinados em Dois Estágios.

Assim como no cotidiano das empresas, os valores associados aos objetos e itens

podem estar relacionados a grandezas de natureza quantitativa ou qualitativa distintas. Neste

Corte Guilhotinado

Corte Vertical Corte Horizontal

Corte Guilhotinado

1º Estágio 2º Estágio Itens Produzidos

P2

P1 P1 P3

P2 P2

P1 P1 P3

P2 P2 P2

P1 P1 P3

30

trabalho, os cortes guilhotinados são realizados em objetos idênticos, com suas dimensões

previamente padronizadas, onde não se fez necessário discutir seu valor. Porém, aos itens

têm-se associado um valor de utilidade que pode ser a medida de sua área ou estar relacionado

à sua importância em presença aos outros itens.

Com relação ao número de itens existentes em um padrão de corte, o problema pode

ser restrito ou irrestrito. Se não houver restrições de limitação associadas ao número de itens,

o problema é irrestrito. Caso contrário, o problema é dito restrito. A imposição de um limite

superior à quantidade de um determinado item no padrão de corte, assim como o

desimpedimento relativo ao número de estágios permitidos, acrescenta considerável

dificuldade à resolução deste problema.

Para o melhor entendimento dos problemas objeto de estudo deste trabalho, as seções

seguintes discriminaram as especificidades do PCEBG e do PCBGR.

3.1 PROBLEMA DE CORTE DE ESTOQUE BIDIMENSIONAL GUILHOTINADO

Com os padrões de corte bidimensionais guilhotinados definidos e uma quantidade

de objetos em estoque suficiente para atender a uma demanda de itens pré-estabelecida, o

PCEBG consiste em escolher quais e quantos destes padrões devem ser executados para que

todos os itens sejam produzidos. É importante ressaltar que esta seleção dos objetos pode ser

modelada como um problema de Programação Linear Inteira. A formulação clássica para o

PCEBG a seguir, consiste em determinar o número de vezes xj que cada padrão de corte j é

utilizado, de forma a atender a demanda di, consumindo-se o menor número possível de

objetos.

n

jj=1

n

ij j ij=1

j

Min x

s.a: a x d , i = 1,...,m (3.1)

x 0 e Inteiro, j = 1,...,n

≥

≥

∑

∑

Onde:

� xj é a variável que representa o total de vezes que o padrão de corte j é utilizado;

� aij é a constante que indica número de itens i gerados no padrão de corte j;

� di é a constante que indica a demanda de itens i;

� m é a constante que indica o número de itens distintos;

� n é a constante que indica o número total de padrões de corte.

31

A condição que o modelo impõe às variáveis xj de não assumir valores contínuos

torna o problema difícil de ser resolvido, até para instâncias relativamente pequenas. Mas

mesmo resolver a relaxação contínua do modelo pode não ser fácil. Se a quantidade de itens

diferentes, encontrados em problemas de médio e grande porte, promove um aumento

considerável no número n de padrões viáveis e para encontrar a solução ótima da relaxação

contínua é preciso conhecer todos os padrões de corte, então a utilização do método simplex

para resolução deste problema se torna inviável nestas circunstâncias, visto que o número de

colunas do modelo pode ultrapassar facilmente a casa dos bilhões.

Esse impedimento pode ser contornado com o método conhecido como Geração de

Colunas (DANTIZG; WOLFE, 1960). Este método pode ser visto como uma extensão do

Simplex Revisado, onde o apreçamento (pricing) das variáveis é realizado através da

resolução de um subproblema, e foi primeiramente introduzido por Gilmore e Gomory (1961,

1963) para versão unidimensional desse problema.

De forma geral, a GC é iniciada montando-se o Problema Linear Mestre (PL Mestre),

que corresponde ao modelo 3.1 sem a restrição de integralidade e contendo apenas um

pequeno subconjunto das variáveis, correspondendo a alguns dos muitos padrões de corte

viáveis. Por exemplo, este subconjunto inicial pode ser formado apenas pelos padrões de corte

homogêneos, onde um único item é colocado o maior número de vezes possível. A GC

baseia-se na utilização do método do simplex revisado, onde, a cada iteração, é gerado e

inserido um novo padrão desde que ele possa melhorar o valor da função objetivo. Caso

contrário, a solução corrente relaxada é ótima. Sendo o problema de minimização, deve-se

buscar por novos padrões que correspondam as variáveis com custo reduzido negativo. Sejam

cj = 1

zj = cB B-1 aj ⇔ zj = П aj ⇔ zj = ∑ πi

mi=1 aij

Onde:

� П é o vetor dos multiplicadores duais;

� cj é o coeficiente da variável j na função objetivo no PL Mestre;

� cB é o vetor de coeficientes das variáveis básicas na função objetivo no PL Mestre;

� B-1 é a inversa da matriz dos coeficientes das variáveis básicas nas restrições no PL

Mestre;

� aj é a coluna da variável j na matriz dos coeficientes do PL Mestre e aij é o coeficiente na

linha i nessa coluna.

32

O custo reduzido de uma variável j é dado por cj - zj. O objetivo de selecionar essas

melhores colunas ou padrões com custo reduzido negativo resulta no seguinte subproblema:

[ ]

m

i i

t

1 m

i=1

i

Min (1 - π y )

s.a: é um padrão viável (3.2)

y 0 e

y , ..

In

.,

o

y

teir≥

∑

Onde:

� yi é a variável que representa o número de itens i no padrão de corte;

� πi é o multiplicador da restrição i no PL Mestre.

É importante ressaltar que no PCEBG tratado neste trabalho, o subproblema 3.2 seria

apenas um PCBGI com peso. Ainda assim, é dada a devida ênfase ao PCBGR, pois este além

de ser resolvido pelos algoritmos propostos, também é fundamental na resolução da instância

residual obtida após o arredondamento da solução ótima do PL Mestre.

A relaxação contínua do modelo (3.1) costuma ser muito forte, no sentido em que o

limite inferior obtido costuma ser muito próximo da solução ótima. Para o caso do PCE

Unidimensional, antes do trabalho de Marcote (1986) não se conhecia uma única instância em

que esse limite inferior arredondado para cima não fosse igual ao valor da solução ótima.

Depois disso, Scheithauer e Terno (1995) propuseram a seguinte conjectura, conhecida como

Modified Integer Round-Up Property (MIRUP):

Conjectura MIRUP (para o caso unidimensional). O limite inferior do modelo 3.1

arredondado para cima está no máximo uma unidade abaixo do valor da solução ótima

inteira.

Até hoje, a maior diferença conhecida entre o limite inferior e a solução ótima é de 1,16666...

(RIETZ et al., 2002). Entretanto, apesar de um grande esforço de pesquisa, ainda não foi

possível provar essa conjectura.

Não foi publicada uma conjectura equivalente para qualquer variante do PCE

Bidimensional, mas o autor desta tese desconhece a existência de alguma instância que mostre

que ela não é verdadeira.

3.2 PROBLEMA DE CORTE BIDIMENSIONAL GUILHOTINADO RESTRITO

O PCBGR consiste em determinar a melhor forma de se gerar uma quantidade de

itens menor ou igual a uma demanda pré-estabelecida, realizando cortes ortogonais do tipo

33

guilhotinado em um objeto também retangular e de dimensão insuficiente para atender toda a

demanda. Diferentemente do problema já apresentado, o PCBGR é abordado na literatura

como uma seleção de itens para um objeto.

Seja o objeto (C, L), de comprimento C e largura L, n itens com demanda di e

dimensões fixas pi = (ci, li), com i = 1,...,m. Uma solução ótima do PCBGR consiste em

determinar o melhor arranjo destes itens, que não extrapolem as dimensões do objeto, nem

apresentem superposição dos mesmos, por meio de cortes guilhotinados, respeitando os

limites di. Então, esta seleção de itens, que atribui o maior somatório de utilidade a um padrão

de corte restrito, pode ser descrito pelo seguinte modelo analítico.

[ ]

m

i ii=1

i

t

1 m

Max v y

s.a: é um padrão viável (3.3)

y 0

y , .

e

.., y

Inteiro≥

∑

Onde:

� yi é a variável que representa o número de itens i produzido no padrão de corte;

� vi é a constante que indica o valor de utilidade do item i.

A viabilidade de um padrão de corte depende das restrições geométricas e

operacionais envolvidas em cada problema. Diante da dificuldade de se apresentar uma

formulação que utiliza cortes guilhotinados não estagiados para o PCBGR, são desenvolvidos

nos próximos Capítulos algoritmos primais e duais, utilizando as técnicas GRASP, PD e PI,

para a resolução do problema supracitado, com estratégias que se distinguem pela forma

como é determinado o valor de utilidade e a permissão por rotação dos itens.

3.3 REVISÃO BIBLIOGRÁFICA

Diversos pesquisadores têm se dedicado a buscar soluções para os problemas de

corte de estoque. Alguns trabalhos, referindo-se ao problema abordado serão citados seguindo

uma evolução cronológica.

Em trabalhos pioneiros, Gilmore e Gomory (1961, 1963) propuseram o

procedimento Geração de Colunas (GC) para obtenção de soluções aproximadas com garantia

de qualidade para o PCE Unidimensional. Para a resolução eficiente do subproblema da

mochila (equivalente ao problema de corte unidimensional), Gilmore e Gomory apresentaram

em 1961, uma PD e, em 1963, um algoritmo de enumeração lexicográfica.

Gilmore e Gomory (1965) trataram do PCEBG restrito a dois e três estágios aplicado

ao corte de rolos de papel. Nesse trabalho, o subproblema de corte é decomposto em duas

34

etapas que são resolvidas pelo algoritmo lexicográfico. Na primeira etapa, são produzidas

faixas ótimas, maximizando o valor dos itens que são encaixados em uma faixa com largura lj

(lj ≤ L), e na segunda etapa, as faixas são selecionadas e arrumadas em um retângulo (C, L),

com o intuito de gerar um padrão de corte com maior valor possível. Com respeito à geração

de padrões em dois ou três estágios, em dois estágios é imposto que os itens pertencentes às

faixas tenham larguras iguais, e em três estágios é necessário apenas que a largura dos itens

que compõem a faixa (C, lj) não seja superior à largura lj da faixa.

Já em Gilmore e Gomory (1966), foi apresentada uma rotina fundamentada em PD,

que gera padrões guilhotinados para o PCE Bidimensional k-estagiado. Como ainda ocorre, a

PD apenas pode ser aplicada de forma eficiente nos casos em que o número de vezes que um

item pode ser produzido em um padrão de corte não está limitado, ou seja, são problemas

irrestritos.

Herz (1972) propôs uma alteração na PD apresentada por Gilmore e Gomory (1966),

redefinindo as funções recursivas para determinar o melhor padrão de corte na resolução do

PCBGI. Segundo Oliveira e Ferreira (1993), as melhorias feitas por Herz (1972) e

posteriormente por outros pesquisadores não compensam o acréscimo de dificuldade na

implementação desses algoritmos de PD, nem suprime o verdadeiro problema do algoritmo de

Gilmore e Gomory, ou seja, continuam não sendo praticáveis para instâncias de médio ou

grande porte do problema. Como constatado a seguir no presente trabalho, isso não é mais

verdade. Atualmente, algoritmos de PD são capazes de resolver bem instâncias com

dimensões bastante razoáveis.

Utilizando um algoritmo de busca em árvores, que emprega uma rotina baseada no

problema de transporte, Christofides e Whitlock (1977) sugeriram um método exato para

resolução do PCBGR que utiliza PD junto a um procedimento para a avaliação de nós. Neste

caso, cada nó determinado por um conjunto de itens cortados, a localização do próximo corte

a ser efetuado e os ramos da árvore são definidos com as condições impostas para realização

de um corte guilhotinado.

Wang (1983) apresenta dois métodos combinatórios que geram padrões de corte a

partir de uma sequência de construções horizontais e verticais em estruturas resultantes da

composição dos itens requeridos. Estas estruturas são produtos do agrupamento dos itens na

horizontal ou na vertical. Com a finalidade de diminuir o número de subconjuntos de

estruturas armazenados, adota-se um limite para o percentual de perda aceitável em cada

subconjunto. Desta forma, as abordagens heurísticas propostas nesse trabalho são clássicas na

literatura do PCBGR.

35

Beasley (1985) propôs uma formulação baseadas em PD para o PCBGI que,

diferentemente das propostas feitas por Gilmore e Gomory (65) e, posteriormente, por

Christofides e Whitlock (1977), não restringe o número de estágios no padrão de corte. Essa

fórmula de recorrência é de grande importância no desenvolvimento dos algoritmos descritos

neste trabalho para o PCEBG e, portanto, será apresentada de forma mais detalhada no

Capítulo 5.

Oliveira e Ferreira (1990) introduzem modificações no algoritmo desenvolvido por

Wang, melhorando o desempenho. O algoritmo Wang Modificado (MWA) é o resultado de

uma alteração no nível de aspiração, isto é, no critério de rejeição de soluções indesejáveis.

Desta forma, o algoritmo avalia a perda associada a cada solução parcial construída (padrão

embrionário). Caso este valor seja maior que o limite estabelecido, a solução parcial é

rejeitada.

O PCBGI é tratado por Morabito, Arenales e Arcaro (1992) adotando a representação

grafo E/OU, apresentada anteriormente em Morabito et al. (1989), para construção de

soluções viáveis do referido problema. Um percurso completo no grafo supracitado representa

uma sequência de cortes guilhotinados (arcos) a ser efetuada no objeto original, produzindo

novos retângulos (nós) de forma a gerar uma solução viável para o problema. O caminho a ser

escolhido é aquele que maximiza o valor dos itens gerados e, portanto, representa o melhor

padrão de corte produzido. Nesse trabalho, a proposta de uma busca híbrida, combinando as

estratégias clássicas de busca depht-first e hill-climbing com procedimentos heurísticos

específicos, conseguem diminuir significantemente os branchings e, em consequência, o

tempo de execução.

Um procedimento de busca em grafos E/OU invertido foi apresentado por Alvarenga

e Daza (1992) para o PCBGR. A composição entre retângulos, tal como empregado no

algoritmo de Wang, foi representada por um grafo E/OU invertido, sendo que cada estrutura

equivale a um nó e cada agrupamento entre as estruturas representa um arco. Os nós são

agrupados dois a dois para gerar um terceiro. Assim, um par de nós dá origem a dois novos

nós considerando a geração de um agrupamento horizontal e um vertical. Quando comparado

ao algoritmo Wang Modificado, apresentou vantagens, tanto em relação à memória requerida

como em número de operações.

Os algoritmos heurísticos Busca Tabu e Simulated Annealing são apresentados por

Amaral (1994) para tratar o PCBGR. Com o objetivo de produzir padrões, de uma forma

ótima, esta abordagem permite aceitar padrões de corte inviáveis como soluções na busca do

melhor padrão. Sendo assim, uma penalidade é inserida na função objetivo, de forma a

36

conduzir o procedimento para uma solução viável. Para ilustrar a efetividade dos algoritmos

propostos, foram apresentados resultados computacionais, descrevendo seus respectivos

desempenhos para alguns exemplos gerados aleatoriamente e outros extraídos de trabalhos

considerados na literatura. As instâncias, assim como os resultados apresentados pelos

algoritmos Busca Tabu e Simulated Annealing, foram utilizadas para validar a versão original

do algoritmo G2D (VELASCO, 2005), que será abordada no Capítulo 4.

Christofides e Hadjiconstantinou (1995) apresentam algoritmo de busca em árvores

para resolução do PCBGR, que é um melhoramento do algoritmo proposto por Christofides e

Whitlock (1977). Esse algoritmo exato diminui o espaço de soluções a ser examinado,

utilizando um limite superior proveniente de uma relaxação do espaço de estados da

formulação de PD para o problema. Como o limite superior dessa PD relaxada depende do

vetor de pesos q, um algoritmo inspirado no método do subgradiente foi proposto para obter

bons pesos. Os resultados obtidos indicam que este procedimento executa razoavelmente bem

problemas de porte médio e apresenta um desempenho computacional bem superior à

proposta de Christofides e Whitlock.

Em Daza, Alvarenga e Diego (1995) foi proposto um algoritmo exato para tratar o

PCBGR. Uma generalização dos algoritmos apresentados por Wang (1983) e Oliveira e

Ferreira (1990) foi usada para definir o algoritmo AAO*, que é um método de busca sobre

grafos E/OU aditivo. Esses grafos são usados para representar uma combinação entre as

estruturas, garantindo a viabilidade do padrão a ser gerado. O algoritmo AAO* usa

informação futura para orientar a busca no espaço de soluções. Para isto, uma função é

definida como a medida aproximada da perda futura associada a uma solução parcial.

Fazendo uso dessa função, denominada função heurística, é possível analisar várias

alternativas percorrendo o domínio do problema parcialmente. Esse método é um resultado

importante porque, por meio de uma representação adequada, pode ser usado não somente

para resolver o PCBGR, mas também resolver outros problemas tão difíceis.

Uma abordagem em grafo E/OU para o PCBGR estagiado foi proposta por Morabito

e Arenales (1996). Essa proposta consiste em representar padrões de corte como caminhos

completos no grafo E/OU, onde os nós representam os retângulos provenientes do objeto e os

arcos representam os cortes guilhotinados, respeitando o número máximo de estágios. Além

do fato da abordagem em grafo E/OU poder controlar restrições importantes, esse

procedimento pode ser facilmente estendido para resolver o Problema de Empacotamento

Tridimensional.

37

Em um trabalho pioneiro, Vieira Neto (1999) utilizou a técnica GRASP na resolução

do PCE Unidimensional. Como base para o desenvolvimento do algoritmo GRASP, foi

utilizada a técnica heurística First Fit Decreasing (FFD). Na implementação da fase de

construção do algoritmo proposto por Vieira Neto, foi criada a estratégia de compor a Lista

Restrita de Candidatos aplicando o parâmetro de aleatoriedade ao valor dado por uma função

gulosa, que retorna o comprimento do maior item com demanda não atendida. Utilizando

dados de problemas reais e da literatura, foram executados testes computacionais que

permitiram a comparação entre a FFD e a GRASP. Demostrando assim, a eficiência do

algoritmo GRASP na otimização de cortes unidimensionais.

Cung, Hifi e Le Cun (2000) desenvolveram um algoritmo Branch-and-Bound, que é

uma nova versão do algoritmo proposto por Hifi (1997a) para o PCBGR. Para melhorar o

desempenho do algoritmo, foi aumentado o limite inferior inicial, diminuindo inicialmente o

espaço de busca. Também se tentou aperfeiçoar o limite superior efetuado a cada nó

desenvolvido na árvore, aplicando algumas combinações simples e eficientes. Além disso,

foram introduzidas novas estratégias simétricas usadas para negligenciar alguns padrões de

corte duplicados.

Inspirados na busca de um melhor desempenho computacional dos métodos de busca

orientada, Parada, Pradenas e Solar (2000) sugeriram um método híbrido para resolução do

PCBGR e, também, da variante não guilhotinada. O algoritmo reuniu elementos construtivos

dos métodos de busca informada e elementos evolutivos dos algoritmos genéticos. A proposta

consiste em utilizar ramificações reguladas na geração dos nós intermediários, armazenando

as populações de nós que evoluíram segundo os princípios envolvidos nos algoritmos

genéticos.

Em Alvarez-Valdés, Parajón e Tamarit (2002a), foi proposto um sofisticado

algoritmo Busca Tabu (TS500), para tratar instâncias de grande porte do PCBGR, que obtém

resultados de alta qualidade em tempos computacionais moderados. Também foram

apresentados mais dois algoritmos, um GRASP puro muito rápido que retorna bons resultados

e outro que utiliza a GRASP com Path Relinking (GR/PR), tanto para problemas restritos

como irrestritos. Para auxiliar na construção dos padrões de corte, foram propostos dois

algoritmos heurísticos, baseados em limites superiores simples (BK1 e BK2) que são obtidos

resolvendo um problema de mochila. A fase de melhoria está focalizada na fusão de cada

retângulo desperdiçado, isto se possível, com um item adjacente, para criação de um novo

retângulo que poderia ser cortado com maior valor. Em tal processo, dois retângulos são

consideramos adjacentes se eles tiverem um lado em comum. O critério de parada utilizado

38

pelo algoritmo GRASP é um determinado número de iterações sem aperfeiçoar a melhor

solução conhecida. Os resultados computacionais serão explorados no Capítulo 4 para fins de

comparação com a versão reativa do algoritmo G2D.

O estudo computacional apresentado por Alvarez-Valdés, Parajón e Tamarit (2002b)

considerou o PCEBG com múltiplos objetos sendo abordado pela técnica GC, onde a cada

iteração um padrão de corte é obtido como solução de um subproblema. Na resolução do

subproblema foi utilizada a técnica de PD proposta por Beasley (1985) e, também, três

heurísticas baseadas nas metodologias GRASP e Busca Tabu. Para obter a solução inteira a

partir da solução ótima do PL Mestre, segundo o clássico processo de Gilmore e Gomory,

foram considerados três procedimentos: arredondamento para cima, truncamento na árvore

Branch-and-Bound e a solução do problema residual. Os resultados demostraram que as

melhores soluções foram obtidas com a PD de Beasley (1985), com considerável custo

computacional.

Vieira Neto (2004) apresentou três algoritmos baseados na técnica GRASP, sendo

que dois foram desenvolvidos com a metodologia GRASP com filtro, para o PCE

Unidimensional. Esse trabalho teve como escopo avaliar a independência entre as soluções

finais e as soluções iniciais construídas, assim como a influência do parâmetro de

aleatoriedade nas soluções finais. Os algoritmos foram testados computacionalmente,

utilizando instâncias geradas aleatoriamente e instâncias práticas retiradas da indústria. Os

testes da GRASP com filtro apresentaram resultados superiores aos obtidos pela heurística

FFD.

Hifi (2004b) propõe um algoritmo híbrido que utiliza a técnica hill-climbing de busca

em profundidade combinada com alguns procedimentos baseados em PD para tratar o

PCBGR, nos casos com e sem peso conferido aos itens. Com o limite inferior calculado a

partir da resolução de uma série de problemas da mochila, para construção das faixas

horizontais e verticais, os autores afirmam que a aplicação de estratégias hill-climbing

promovem ganho computacional em tempo e qualidade. Os resultados computacionais foram

superiores aos mostrados em Alvarez-Valdés et al. (2002a).

Com a metodologia GRASP sendo utilizada na composição de faixas horizontais e

verticais do padrão de corte, o algoritmo GRASP-2D (G2D) foi proposto por Velasco (2005)

para resolver simultaneamente o PCBGR e o PCEBG, no caso não estagiado, sem peso e

admitindo a rotação dos itens. Com o intuito de validar a heurística proposta, as soluções dos

testes realizados foram comparadas as soluções produzidas com algoritmos Busca Tabu e

Simulated Annealing, propostos por Amaral (1994) para resolver PCBGR. Os resultados

39

foram bastante significativos, demonstrando que a GRASP pode ser aplicada com sucesso

para o PCBGR.

Cui (2007) apresenta um algoritmo que combina as técnicas de recursão com a

abordagem Branch-and-Bound para resolução do PCBGI sem rotação, retornando a solução

denominada padrão SB (simple block). Inicialmente é selecionado um item denominado

principal, colocado no canto inferior esquerdo do objeto. Sendo que, a cada corte no objeto é

produzida apenas uma faixa SB. Adota-se um limite superior externo para podar alguns ramos

pouco promissores durante o processo de busca. Os resultados são obtidos em tempos

computacionais razoáveis e indicaram que o algoritmo é eficiente.

Chen (2008) apresenta um algoritmo heurístico recursivo para o PCBGR sem

rotação. Com uma estratégia que consiste em dividir o objeto em subretângulos menores,

efetuando cortes horizontais ou verticais, a partir de cada item selecionado e posicionado no

canto inferior esquerdo. O algoritmo utiliza como limite superior o valor da melhor solução

do PCBGI, obtida com o algoritmo recursivo apresentado por Cui (2007). Os resultados

computacionais em instâncias da literatura foram satisfatórios na comparação com a Busca

Tabu proposta por Alvarez-Valdés et al. (2002a) e o híbrido TDH2 de Hifi (2004b).

Cintra, Miyazawa, Wakabayashi e Xavier (2008) apresentou um artigo que trata das

variantes do PCBGI, com e sem limitação de estágios, do PCEBG considerando um único

objeto e múltiplos objetos e o problema 1,5 dimensional, conhecido na literatura como strip

packing, todos admitindo também a rotação dos itens. Em destaque, a partir de uma

modificação na fórmula de recorrência proposta por Beasley (1985) que, juntamente com os

pontos de discretização definidos por Herz (1972), propuseram o algoritmo Dynamic

Programming (DP), que confirmou sua eficiência ao produzir a solução ótima de uma

instância clássica do PCBGI até então em aberto. O algoritmo DP é de grande importância no

presente trabalho e será apresentado com mais detalhes no Capítulo 5. Considerado uma

importante referência da literatura do PCEBG com um objeto, os resultados obtidos com os

algoritmos GC propostos para este problema são confrontados no presente trabalho.

Morabito e Pureza (2010) apresentam um procedimento heurístico que emprega PD e

busca em grafo E/OU para resolução do PCBGR, retratando as variantes que os itens podem

ou não ter seu valor igual à medida de sua área. O método consiste em combinar a formulação

dinâmica proposta por Christofides e Hadjiconstantinou (1995), com a abordagem de busca

em grafo E/OU e uma heurística de viabilização para produzir padrões de corte não estagiado.

O excelente desempenho desse algoritmo foi comprovado a partir das comparações com os

algoritmos propostos por Fayard et al. (1998), Alvarez-Valdés et al. (2002a) e Hifi (2004b) e

40

dos certificados de otimalidade para as respectivas instâncias teste. Além disso, tais resultados

computacionais são utilizados neste trabalho com o propósito de validar as respectivas

versões propostas dos algoritmos RG2D e X2D.

Em Silva, Alvelos e Carvalho (2010), para o PCEBG limitado a dois e três estágios,

foi proposto um modelo de PI. Em tal modelo, considerado uma extensão do “one-cut model”

proposto por Dyckhoff (1981) para o PCE Unidimensional, as colunas correspondem aos

possíveis cortes no objeto e as respectivas variáveis representam o número de vezes que o

corte é realizado. Um algoritmo ficou responsável por fornecer como dado de entrada do

modelo um conjunto com todos os cortes possíveis para o modelo. Nessa proposta,

obtiveram-se os ótimos da maioria das instancias, limitando-se o tempo de execução em duas

horas, também mostrou eficiência quando comparado com os modelos de propostos por Lodi

e Monaci (2003) e Puchinger e Raidl (2007), para os casos de dois e três estágios, nesta

ordem.

Furini, Malaguti, Durán, Persiani e Toth (2012) consideraram o PCEBG, onde os

itens são obtidos a partir de cortes, em dois estágios, realizados em objetos de tamanhos

diferentes. Nesse trabalho, foi proposto um algoritmo heurístico baseado na técnica GC, com

o subproplema sendo tratado como um Problema da Mochila Bidimensional com cortes

guilhotinas em dois estágios. Para resolução do problema da mochila supracitado, os autores

evidenciam a definição de um modelo de PIM, assim como um procedimento heurístico

baseado em PD. Os resultados computacionais, para os casos com e sem rotação dos itens,

demostraram a eficácia da proposta quando comparados com Cintra et al. (2008).

Em Dolatabadi, Lodi e Monaci (2012), são apresentados dois algoritmos exatos para

o Problema da Mochila Bidimensional Guilhotinada sem rotação. O algoritmo A1 encontra as

melhores soluções em recursões que fazem busca exaustiva no espaço de soluções.

Entretanto, não é completo porque precisa de um limite inferior e outro superior, ambos

provenientes de algum algoritmo externo. Assim, estes limitantes são tidos como dados de

entrada nesse algoritmo. Por exemplo, nas instâncias de grande porte e indicadas pela sigla

APT, os respectivos limites são encontrados em (HIFI, 2004b) e (CHEN, 2008). Nas demais

instâncias teste, uma heurística aleatorizada de múltiplas descidas baseada no método FFD

obtém o limite inferior e o superior é dado pelo menor valor entre os valores do padrão ótimo

não guilhotinado e do irrestrito. Esse algoritmo exato resolve a maioria das instâncias

clássicas de forma bem rápida, mas pode não melhorar seu limite inferior em outras. É

importante destacar que alguns dos seus melhores resultados são comparados com os

algoritmos propostos RG2D e X2D.

41

Furini, Malaguti e Thomopulos (2016) propuseram um algoritmo para o Problema da

Mochila Bidimensional Guilhotinada não estagiado em que os cortes são modelados em PIM.

Nesse modelo, cada decisão de corte é representada pelo terno ordenado (q, j, o), onde q é à

distância do canto inferior esquerdo, de um objeto ou subretângulo de tipo j, no qual um corte

com orientação o é realizado. Sua função objetivo determina o valor de utilidade total dos

itens produzidos e o conjunto de restrições impõe: que o número de vezes que determinado

subretângulo é cortado não exceda o número de vezes que o mesmo subretângulo é obtido em

outros subretângulos; o objeto é usado uma única vez; e a demanda dos itens não seja

excedida. O modelo tem complexidade pseudo-polinomial, mas é apresentada uma discussão

sob quais condições o número de variáveis pode ser reduzido.

No Quadro 3.1 encontra-se uma síntese dos artigos revisados que tratam as variantes

evidenciadas do Problema de Corte de Estoque. Com o mesmo propósito, o Quadro 3.2

designa-se aos trabalhos que abordam os casos em destaque do Problema de Corte

Bidimensional. Essas descrições consideram os autores e a ordem cronológica dos trabalhos,

explicitando as principais técnicas que contribuíram na resolução dos respectivos Problemas

de Corte e Empacotamento.

QUADRO 3.1 – Artigos Revisados do Problema de Corte de Estoque.

Autores Técnicas Problemas

Gilmore e Gomory (1961) GC e PD PCE

Unidimensional

Gilmore e Gomory (1963) GC e Enumeração

Lexicográfica PCE

Unidimensional

Gilmore e Gomory (1965) GC e Enumeração

Lexicográfica PCEBG

Gilmore e Gomory (1966) GC e PD PCEBG

Herz (1972) Busca em Árvore, PD e

Heurística PCEBG

Wang (1983) Combinatória e Heurística PCEBG

Vieira Neto (1999) Metaheurística PCE

Unidimensional

Alvarez-Valdés et al. (2002b) GC, Branch-and-Bound,

PD e Metaheurística PCEBG

Vieira Neto (2004) Metaheurística PCE

Unidimensional Velasco (2005) Metaheurística PCEBG

Cintra et al. (2008) GC e PD PCEBG

Silva et al. (2010) PI PCEBG

Furini et al. (2012) GC, PD, PIM e Heurística PCEBG

42

QUADRO 3.2 – Artigos Revisados do Problema de Corte Bidimensional.

Autores Técnicas Problemas

Christofides e Whitlock (1977) Busca em Árvore e PD PCBGR

Wang (1983) Combinatória e

Heurística PCBGR

Beasley (1985) PD e Heurística PCBGI

Morabito et al. (1989) Busca em Grafos e

Heurística PCBGI

Oliveira e Ferreira (1990) Combinatória e

Heurística PCBGR

Morabito et al. (1992) Busca em Grafos e

Heurística PCBGI

Alvarenga e Daza (1992) Busca em Grafos,

Combinatória e Heurística PCBGR

Amaral (1994) Metaheurística PCBGR

Christofides e Hadjiconstantinou (1995) Busca em Árvore e PD PCBGR

Daza et al. (1995) Busca em Grafos,

Combinatória e Heurística PCBGR

Morabito e Arenales (1996) Busca em Grafos e

Heurística PCBGR

Cung et al. (2000) Branch-and-Bound, PD e

Heurística PCBGR

Parada et al. (2000) Busca em Grafos e

Metaheurística PCBGR

Alvarez-Valdés et al. (2002a) Metaheurística PCBGR/PCBGI

Hifi (2004b) Busca em Grafos, PD e

Heurística PCBGR

Velasco (2005) Metaheurística PCBGR

Cui (2007) Estrutura Recursiva e Branch-and-Bound

PCBGI

Chen (2008) Estrutura Recursiva e

Heurística PCBGR

Cintra et al. (2008) PD PCBGI

Morabito e Pureza (2010) Busca em Grafos, PD e

Heurística PCBGR

Dolatabadi et al. (2012) Estrutura Recursiva e

Heurística PCBGR

Furini et al. (2016) PIM PCBGR

43

4 AMPLIAÇÕES DO ALGORITMO G2D PARA O PCBGR

Admitindo que nem sempre é possível achar a solução ótima para um problema

fortemente NP-Difícil, certamente, a composição do padrão ótimo do PCBGR deve possuir

faixas otimizadas e um arranjo preciso dessas faixas. Em decorrência a essa dedução, provém

a ideia de implementar um algoritmo sob forte influência da metodologia GRASP que atua

diretamente no processo de formação e organização de faixas guilhotinas do padrão de corte.

Originalmente chamado de GRASP-2D (G2D), o presente capítulo descreve a

evolução deste algoritmo especificando as propostas de melhorias implementadas que

culminaram nas versões dos algoritmos G2D Reativo para resolução das variantes do PCBGR

que combinam a seguintes características: quando o valor dos itens está associado

exclusivamente a sua medida de área (sem peso) ou sem essa distinção (com peso) e com

proibição ou permissão destes itens sofrerem uma rotação de 90º em torno de seus eixos de

simetria.

Na seção seguinte, a metodologia GRASP recebe o devido destaque e são

apresentadas as definições essenciais na implementação dos algoritmos propostos.

4.1 METAHEURÍSTICA GRASP

A metodologia Greedy Randomized Adaptive Search Procedure (GRASP), surgida

na década de 80 e desenvolvida por Feo e Resende (1989), é essencialmente um procedimento

mult-start, em que a cada iteração tem-se a combinação de uma heurística construtiva com

uma de busca local. O método GRASP é um procedimento iterativo probabilístico que atua

por amostragem em um espaço de soluções restrito. A cada iteração é gerada uma solução de

forma míope, aleatória e adaptativa que será refinada por uma busca local, sendo a melhor

solução global mantida como resultado final. Assumindo um problema de maximização, o

pseudocódigo genérico GRASP é apresentado como segue.

Algoritmo GRASP( ) 1. melhorSolução ← -∞; 2. Enquanto (Critério de parada não satisfeito) faça 3. solução ← ConstruçãoGulosaAleatória( ); 4. solução ← BuscaLocal (solução); 5. Se valor(solução) > valor( melhorSolução) então melhorSolução ← solução; 6. Retorna (melhorSolução);

Fim GRASP

Entre as linhas 2 e 5 temos um conjunto de instruções que são executadas

repetidamente até que uma condição de parada seja satisfeita. A fase de construção da

44

GRASP é indicada na linha 3, enquanto a linha 4 é a fase de busca local, que encontra a

melhor solução dentro de uma certa vizinhança da solução de entrada gerada pelo construtivo.

Caso a busca local tenha obtido alguma melhoria na solução corrente, a solução é atualizada

na linha 5. Todo esse processo pode ser interrompido definindo-se um número máximo de

iterações, determinando um tempo máximo de execução ou quando certo valor de solução

procurada for obtido (FEO; RESENDE, 1995). Neste trabalho, opta-se como critério de

parada por um número máximo de iterações.

Como o algoritmo GRASP constitui-se a cada iteração de duas fases, a primeira de

construção e a segunda de melhoria, estas são descritas separadamente como segue.

4.1.1 FASE DE CONSTRUÇÃO DA GRASP

Basicamente, na primeira fase, uma solução viável é construída iterativamente

incluindo um elemento de cada vez. Esse elemento é retirado aleatoriamente de um conjunto

denominado de Lista Restrita de Candidatos (LRC). A LRC é composta pelos elementos mais

interessantes de uma lista constituída de candidatos a serem incluídos em uma solução,

segundo um critério guloso. Essa técnica de escolha permite que soluções distintas sejam

produzidas em cada iteração GRASP. A cada elemento incluído na solução, uma função

gulosa é adaptada. Essa função gulosa estima o benefício associado à inclusão de cada

elemento a uma determinada solução. O pseudocódigo descrito abaixo apresenta a fase de

construção da GRASP.

Algoritmo ConstruirSoluçãoGulosaAleatória ( ) 1. solução ← ∅; 2. Enquanto (solução estiver incompleta) faça 3. LRC ← CriaLRC ( ); 4. x ← SelecionaElementoAleatório (LRC); 5. solução ← solução ∪ {x}; 6. AtualizaFunçãoGulosa (x); 7. Retorna (solução);

Fim ConstruirSoluçãoGulosaAleatória

A construção iterativa de uma solução é iniciada na linha 1 do pseudocódigo. Os

comandos entre as linhas 3 e 6 são repetidos até que a solução seja construída. Na linha 3, a

lista restrita de candidatos é construída a partir de uma função gulosa. Um candidato de LRC

é selecionado ao acaso na linha 4 e acrescentado a solução na linha 5. Na linha 6, a função

gulosa é atualizada de acordo com o elemento incluído.

Um parâmetro α no intervalo [0,1] determina a quantidade de elementos incluídos no

LRC. Seja X um conjunto finito formado pelos elementos possíveis de serem incluídos na

solução, f: X → ℝ uma função gulosa que indica o valor de cada um desses elementos, ou

45

seja, quanto à inclusão desse elemento beneficiaria o valor da solução parcial corrente, e

β = max {f(x); x ∈ X} o maior valor retornado pela função gulosa. O subconjunto LRC,

formado pelos melhores elementos de X, é determinado aplicando o parâmetro α ao valor β na

definição de um intervalo de valores como segue, LRC = {x ∈ X | α.β ≤ f(x) ≤ β}.

Para α = 1 se gera soluções totalmente gulosas e para α = 0 se produz soluções

totalmente aleatórias. Assim, o parâmetro α regula o grau de miopia e aleatoriedade da fase de

construção. Este é o principal parâmetro a ser ajustado no algoritmo GRASP original, pois se

a cardinalidade de LRC for pequena, a diversidade das soluções geradas também se constitui

pequena e, consequentemente, a probabilidade de escapar de um ótimo local de baixa

qualidade na fase de melhoria tende a diminuir. Já uma LRC que apresenta uma cardinalidade

grande, produz muitas soluções diferentes, aumentando a perspectiva de escapar de tal ótimo

local na fase melhoria. Entretanto, isto implica em um acréscimo considerável no número de

iterações com soluções ruins, com baixa probabilidade de melhorar a melhor solução

conhecida. Sendo assim, é imprescindível a análise sobre o valor assumido pelo parâmetro α

com respeito à qualidade das soluções encontradas, número de iterações utilizadas e

vizinhança explorada (FEO; RESENDE, 1995).

4.1.2 FASE DE MELHORIA DA GRASP

A segunda fase é um procedimento de busca local. As soluções construídas pela

primeira fase não são necessariamente de boa qualidade e quase sempre a busca local pode

melhorá-las. Determinada uma estrutura de vizinhança V para o problema Y, que gere um

subconjunto de soluções V(y) a partir de uma solução y do problema. A condição para que

uma solução y seja declarada como um ótimo local é não haver solução melhor em V(y). Na

tentativa de melhorar as soluções originadas na fase de construção, emprega-se o

procedimento de busca local, que examina o espaço de soluções mudando de uma solução

para outra vizinha. A eficiência desta fase está diretamente relacionada à qualidade das

soluções iniciais, a estrutura V e sua estratégia de busca local. A seguir é apresentado o

pseudocódigo de um procedimento básico de busca local para um problema Y sobre uma

vizinhança V para essa fase da GRASP:

Algoritmo BuscaLocal (solução) 1. Enquanto (solução não é localmente ótima) faça 2. Encontrar uma melhor solução y ∈ V(solução); 3. solução ← y; 4. Retorna (solução);

Fim BuscaLocal

46

O laço iniciado na linha 1 é executado até encontrar um ótimo local para uma

vizinhança. A busca por soluções indicada na linha 2 é realizada através de movimentos, isto

é, modificações que transformam uma solução em outra pertencente a sua vizinhança. Caso

uma solução obtida na vizinhança seja melhor que a solução tratada, este vizinho passa a ser a

solução corrente na linha 3. A condição de parada deste procedimento é não haver solução

melhor que a solução atual, em sua estrutura de vizinhança.

4.1.3 GRASP REATIVO

O método GRASP Reativo provém do GRASP clássico e, basicamente, diferencia-se

na fase de construção, quando o parâmetro α é deliberado após uma fina calibragem feita a

partir de uma variação deste parâmetro no decorrer de algumas iterações. Com o intuito de

agregar qualidade às soluções construídas e, consequentemente, obter melhor desempenho na

fase de melhoria, executam-se as demais iterações com o valor do parâmetro α ajustado

(PRAIS; RIBEIRO, 2000).

4.2 ALGORITMO G2D ORIGINAL

Primeiramente, o algoritmo G2D foi proposto por Velasco (2005) e tratou

simultaneamente o PCBGR e o PCEBG, apenas na variante não estagiada, sem peso e com a

possibilidade de rotação dos itens. Fixando-se o parâmetro α e o número máximo de iterações,

a cada execução destas, uma solução do PCEBG é produzida, gerando-se um padrão de cada

vez e atualizando a demanda dos itens já relacionados para que não haja um excesso de

produção. Ao final, este algoritmo retorna além do padrão de corte de maior valor para o

PCBGR, com a função objetivo calculando o seu percentual de aproveitamento em relação à

área do objeto, uma solução de boa qualidade para o PCEBG (VELASCO et al., 2008). Os

resultados computacionais para o PCBGR se mostraram bastante promissores, em testes

realizados em instâncias de até 20 itens, comparados às heurísticas Busca Tabu e Simulated

Annealing (AMARAL, 1994), dando indicativas que o G2D poderia ser aplicado com sucesso

a esse problema.

É importante ressaltar na proposta original que a criação das faixas em um padrão de

corte baseia-se na metodologia GRASP, onde um item é escolhido da LRC na fase de

construção para dar origem a uma faixa horizontal e outra vertical. Os movimentos da fase

seguinte consideram apenas a altura ou o comprimento dos próximos itens a compor as

respectivas faixas horizontal ou vertical, e a escolha das faixas produzidas para integrar um

padrão considera o menor percentual de perda em relação a sua área. Os fundamentos

47

necessários nessa implementação, assim como as distintas fases da GRASP, são apresentadas

nas subseções a seguir.

4.2.1 FUNDAMENTOS PARA IMPLEMENTAÇÃO DO ALGORITMO G2D

Considere o objeto retangular R = (C, L), de comprimento C e largura L, utilizado

para produzir itens também retangulares xi = (ci, li), pertencentes ao conjunto I, com as

dimensões ci ≤ C e pi ≤ L e demandas di previamente estabelecidas, com i = 1,...,m. Estes

elementos podem ser associados a pontos no plano cartesiano já que o objeto e os itens são

representados por pares ordenados. Em relação a um sistema de coordenadas cartesianas com

origem no canto inferior esquerdo de R, a execução de uma série de cortes guilhotinados

paralelos aos eixos coordenados, isto é, aos lados do objeto R, para produção dos itens xi,

definiria um padrão de corte para o PCBGR.

FIGURA 4.1 – Cortes Guilhotinados e Faixas Guilhotinas.

Se o item xi é obtido em R sem sofrer uma rotação de 90º, este é indicado por

pi = (ci, li). Quando posicionado no canto inferior esquerdo de R, esse dá origem a dois tipos

de faixas com a execução de cortes do tipo guilhotina sobre este objeto. Verifica-se na Figura

4.1(a) que uma faixa guilhotina horizontal FH = (C, li) é definida a começar de um corte

guilhotinado horizontal de largura li. Esse corte ainda determina um subretângulo

SR = (C, L-li) que deve ser utilizado, provavelmente, na definição de outras faixas guilhotina

do padrão. Já a Figura 4.1(b), ilustra uma faixa guilhotina vertical FV = (ci, L), obtida a partir

de um corte guilhotinado vertical, de comprimento ci em R. O outro subretângulo originado

com esse corte vertical, SR = (C-ci, L), também tem o propósito de ser aproveitado na

configuração das demais faixas do padrão de corte. Caso xi seja rotacionado, o item passa a

Corte Vertical

Item (ci, li)

Corte Horizontal

C

ci

li

SR

(a)

FH →

ci

li

C

SR L FV ↑

(b)

48

ser designado por ri = (li, ci). Deste modo, as faixas guilhotinas FH = (ci, C) e FV = (li, L) e seus

respectivos subretângulos SR são definidos de forma análoga.

Diante disso, um padrão é distinguido pelo conjunto de faixas guilhotina que o

configura e pela maneira como essas faixas são arranjadas. Conforme observado na Figura

4.2, uma faixa guilhotina é constituída pelo agrupamento de peças na horizontal ou na vertical

e, ao posicionar os itens que dão origem a essas faixas sempre no canto inferior esquerdo de R

ou de SR, fica estabelecido um padrão de corte guilhotinado normal (CHRISTOFIDES;

WHITLOCK, 1977).

FIGURA 4.2 – Faixas Guilhotinas Horizontais e Verticais.

Outra questão importante a ser considerada é que se utiliza uma expressão definida

por caracteres alfanuméricos para descrever uma faixa guilhotina. As letras H e V são

empregadas ao executar faixas guilhotinas horizontal e vertical, nessa ordem. Os itens não-

rotacionados pi pertencentes a estas faixas são simbolizados por P e os itens rotacionados ri

por R. Por exemplo, na Figura 4.2, a expressão H3P1 representa uma FH contendo três itens

p1. Ainda na Figura 4.2, a expressão H3R1 indica que a FH possui três itens r1. Da mesma

forma, uma FV composta por quatro itens p2 é indicada pela expressão V4P2. Assim, uma FV

com quatro itens r2, sua expressão é V4R2 e, também, pode ser conferida na Figura 4.2.

Observe que os caracteres começam sempre por H ou V e se apresentam seguidos de: um

dígito representando a quantidade de itens incluídos, um caractere P ou R indicando a

orientação destes itens e outro dígito, informando o índice deste item inserido.

Para descaracterizar a homogeneidade da faixa, esta deve apresentar outros itens

além do item comprometido na sua geração. Neste caso, novas sequências de caracteres

alfanuméricos iniciadas por M são concatenadas as já formadas por H ou V. A presença desta

Faixas Guilhotinas Horizontais e Verticais

H3P1 P1

P1 P1

H3R1

R1 R1 R1

H3P1M3P2 P2 P2 P2 P1 P1 P1

V4R2

R2

R2

R2

R2 V4P2

P2

P2

P2

P2

49

nova letra particulariza movimentos de melhoria distintos nessas faixas. Se a escolha do

próximo item a compor uma FH, quando comparado aos demais itens com demanda não

atendida e dimensões que não descaracterizem o corte guilhotinado nesta faixa, considera a

largura li deste item, essa melhoria é indicada pela letra M. A ocorrência dessa melhoria em

uma faixa guilhotina horizontal pode ser observada na Figura 4.2 e indicada pela expressão

H3P1M3P2. De forma análoga, considerando a grandeza comprimento ci decisiva na escolha

do próximo item a ser gerado em uma FV, a letra M assinala a efetivação dessa melhoria. Por

exemplo, é compreensível através da Figura 4.2 que uma faixa representada por V4R2M1R1

não inviabiliza algum corte guilhotinado e agrega valor a faixa originária V4R2.

Diante disto, um padrão de corte fica caracterizado pelas diferentes expressões

apresentadas por cada faixa guilhotina, considerando a ordem de registro dessas expressões.

Para exemplificar, a Figura 4.3 ilustra um padrão de corte com três faixas guilhotinas e três

estágios, que pode ser descrito pela sequência de caracteres H2P3M2R5M1P4M1P6M1R7

V2R2 H1P1.

FIGURA 4.3 – Padrão de Corte para o PCBGR.

O somatório das medidas de superfície improdutivas no objeto R define a perda no

padrão de corte e são categorizadas como perda interna e perda externa (WANG, 1983).

Quando um corte realizado em R impossibilita nova faixa guilhotina, a medida de área deste

subretângulo SR é denominada perda externa. Se determinada faixa guilhotina apresenta áreas

improdutivas, estas são apontadas como perda interna. Sendo assim, a perda total de um

padrão de corte equivale à soma das perdas externa e internas de suas faixas guilhotina. Para

G2

G1Ι

G2

G3Ι

Padrão de Corte

Perda Interna

Perda Externa

G3 G1

G3

G3

G3

G2Ι

G2Ι G2Ι G2Ι G2Ι G2Ι G2Ι

P3 P3 R7 R5 P4 R5

FH →

P6

FH →

P1 FV ↑

R2

R2

50

exemplificar, ainda na Figura 4.3, são evidenciados os dois tipos de perda encontrados nos

padrões de corte.

Em resumo, uma solução para o PCBGR é definida por um conjunto de faixas em

um padrão de corte e representadas respectivamente por sequências de caracteres

alfanuméricos. A perda total encontrada na solução equivale à soma das perdas externas e

internas produzidas nas faixas guilhotina que a compõe. Nas seções seguintes, têm-se o

intuito de apresentar como são abordadas as duas fases características da metodologia GRASP

no algoritmo G2D.

4.2.2 FASE DE CONSTRUÇÃO DAS FAIXAS NO ALGORITMO G2D

Nessa fase é realizada a construção de faixas guilhotinas viáveis sobre um retângulo

S = (CS, LS), que pode ser tanto o objeto original R = (C, L) ou subretângulos residuais SR

gerados após o corte de faixas anteriores. Seja y um vetor solução m-dimensional atualizado

com a quantidade de cada item xi ∈ I na solução parcial corrente. O valor di - yi > 0 indica que

o item xi ainda possui demanda a ser atendida e credencia sua inclusão no padrão de corte

corrente. Com as medidas das faixas sendo definidas não somente pelas dimensões de S, mas

também pelo item xk escolhido aleatoriamente na LRC, destaca-se três elementos

fundamentais na concepção desta lista restrita:

i) A função gulosa ga: ℝ2 → ℝ, que associa a cada item xi um único valor g(xi) = ci.li

igual sua medida de área;

ii) O conjunto I constituído dos itens aspirantes a originar uma faixa, com |I| ≤ m e

atualizado se di - yi = 0;

iii) O critério guloso β = max {ga(x); x ∈ I} que retorna a medida de área do maior

item em I.

Dessa forma, LRC = {x ∈ I | α.β ≤ ga(x) ≤ β} apresenta os itens mais interessantes de

I, segundo valor de utilidade, e sua cardinalidade é diretamente influenciada pelo parâmetro α

∈ [0,1]. Em suma, uma seleção aleatória determina o item de LRC responsável por determinar

as dimensões nas faixas guilhotinas horizontal e vertical como segue.

A escolha aleatória de um item xk = (ck, lk) na LRC dá início ao processo de

construção das faixas FH = (CFH, LFH) e FV = (CFV, LFV) no S corrente. A primeira decisão

refere-se a determinação de uma orientação para produção de xk. Se apenas uma das

orientações pk ou rk puder ser obtido nas dimensões de S, xk = pk ou xk = rk, exclusivamente.

Se tanto pk quanto rk couberem em S, um novo sorteio estabelece qual dessas orientações deve

definir xk. Caso não seja viável a geração de xk, a LRC é atualizada sem este item e o sorteio é

refeito.

51

A seguir, são construídas duas faixas guilhotinas viáveis FH = (CS, lk) e FV = (ck, LS),

uma através de um corte horizontal e outra a partir de um corte vertical. Com os vetores m-

dimensionais yH e yV sendo atualizados pelas respectivas quantidades dos itens presentes

nestas faixas, são calculados o número yHk = min{dk-yk, [[CS/ck]]} de itens xk a serem obtidos

na faixa FH e yVk = min{dk-yk, [[LS/lk]]} em FV. Também, nas respectivas faixas, são

determinados os subretângulos residuais SH = (CS-yHk.ck, lk) e SV = (ck, LS-yVk.lk),

caracterizados de perda interna, e seus indicadores percentuais de qualidade dados por

perdaint(FH) = (ga(FH)-ga(xk).yHk)/ga(FH) e perdaint(FV) = (ga(FV)-ga(xk).yVk)/ga(FV). O

pseudocódigo da fase de construção das faixas no algoritmo G2D, denominado

ConstruçãoFaixa, é especificado como segue.

Procedimento ConstruçãoFaixa (I, y, α, S) 1. yH = yV = 0, FH = FV = 0, SH = SV = 0; 2. β ← max {ga(x); x ∈ I}; 3. LRC ← {x ∈ I | α.β ≤ ga(x) ≤ β}; 4. Escolha, aleatoriamente, xk de LRC que mantenha a viabilidade em S; 5. Determine a orientação de xk e construa FH e FV; 6. Atualize yH, SH, yV e SV; 7. Retorna (FH, yH, SH, FV, yV, SV);

Fim ConstruçãoFaixa

Se as faixas homogêneas construídas possuem perda interna suficiente para produzir

algum outro item xj de I, as grandezas cj e lj são analisadas nas dimensões dos subretângulos

SF e SV para providenciais melhorias. Ao final, o procedimento de melhoria detalhado na

subseção seguinte retorna à faixa com menor percentual de perda interna.

4.2.3 FASE DE MELHORIA DAS FAIXAS NO ALGORITMO G2D

No procedimento de melhoria, faixas guilhotinas FH e FV, inicialmente construídas,

são tratadas com o propósito de minimizar a perda interna em ambas e, consequentemente,

obter um melhor aproveitamento dos respectivos subretângulos SH = (CSH, LSH) e SV = (CSV,

LSV) correntes. Para intensificar este processo simbolizado com caractere M, dois conjuntos

BH e BV são criados com a finalidade de acelerar as ações dessa etapa, excluindo movimentos

desnecessários que acarretariam em faixas guilhotinas infactíveis ou fariam descaracterizar o

corte do tipo guilhotinado. Sendo assim definidos

BH = {xi ∈ I | (di-yHi > 0) e ((ci ≤ CSH e li ≤ LSH) ou (li ≤ CSH e ci ≤ LSH))} e

BV = {xi ∈ I | (di-yVi > 0) e ((ci ≤ CSV e li ≤ LSV) ou (li ≤ CSV e ci ≤ LSV))},

os itens pertencentes a BH, assim como os incluídos em BV, não apresentam dimensões que

ultrapassem as de SH e SV, nessa ordem, mantendo assim a viabilidade das faixas quando

52

selecionados para executar melhorias. É importante destacar que no algoritmo G2D original é

permitida a inserção de itens rotacionados nos conjuntos em destaque.

Na faixa horizontal, este processo inicia-se com BH sendo constituído dos itens de I

com demanda positiva e que cabem no subretângulo de perda interna SH atual. Seja o item xj

selecionado neste conjunto por apresentar uma largura maior ou igual aos demais, pois em

caso de empate essa escolha é aleatória. Decerto que a quantidade de itens xj está diretamente

relacionada às dimensões de SH e a sua demanda atualizada, calcula-se o número

yHj = min{dj-yj, [[CSH/cj]]} destes itens a serem incluídos nesta faixa. A cada inclusão de yHj

itens de xj implica na atualização do subretângulo SH = (CSH-yHj.cj, LSH) e dos itens

pertencentes ao conjunto BH. Com o intuito de gerar um melhor aproveitamento da faixa FH,

este processo é repetido enquanto BH não for vazio.

Análogo ao BH, o conjunto BV é constituído pelos itens de I que, ao serem incluídos

no subretângulo SV corrente, não impossibilitariam a efetivação da faixa FV no padrão de

corte gerado. Entre os itens deste conjunto, um item xt também entra na composição da faixa

FV desde que apresente o maior comprimento entre os demais. Nesse caso, a quantidade

yVt = min{dt-yt, [[LSV/lt]]}de itens xt, a serem produzidos no subretângulo SV presente,

considera o mínimo entre a demanda existente e o piso do coeficiente LV/lt. Assim como

SV = (CSV, LSV-yVt.lt), o conjunto BV também é atualizado, até não existir mais item que

melhore o valor de utilidade da faixa FV.

Ao término desta fase, a faixa guilhotina que apresenta o menor percentual de perda

interna é incluída no padrão de corte. Os percentuais de perda interna destas faixas são

atualizados por perdaint(FH) = (ga(FH)-∑ g�(x).� � y�)/ga(FH) e perdaint(FV) = (ga(FV)-

∑ g�(x).� � y�)/ga(FV). Caso haja empate entre estes valores, a escolha da faixa a compor o

padrão de corte é aleatória. Além disso, o subretângulo residual da perda externa deve ser

atualizado de acordo com as dimensões da melhor faixa, isto é, SR = (CS, LS - LFH) ou SR = (CS-

CFV, LS). O pseudocódigo MelhoriaFaixa esboçado a seguir, representa a fase de melhoria das

faixas do algoritmo G2D original.

Procedimento MelhoriaFaixa (I, y, S, FH, yH, SH, FV, yV, SV) 1. Crie BH e BV; 2. Enquanto (|BH| ≠ 0) faça 3. Selecione xj de BH com maior largura, para usar “M”; 4. Atualize yH, SH e BH; 5. Enquanto (|BV| ≠ 0) faça 6. Selecione xt de BV com maior comprimento, para usar “M”; 7. Atualize yV, SV e BV; 8. Determine perdaintFmelhor = min {perdaint(FH), perdaint(FV)}; 9. Atualize y e S relacionado à perdaintFmelhor;

53

10. Retorna (y, S); Fim MelhoriaFaixa

Nessa versão, a fase de melhoria ainda pode ser interpretada como continuação do

procedimento de construção das respectivas faixas FH e FV. Entretanto, os itens utilizados na

nova composição da faixa corrente não mais são retirados da LRC, contrapondo a

metodologia adotada. Sob outra perspectiva, se as faixas FH e FV são analisadas como vetores

de m-dimensonais e suas posições inicialmente preenchidas com as respectivas quantidades

do item escolhido na fase de construção apresentam-se fixas, qualquer simples atualização

destes vetores com estratégias diferentes da construção inicial já caracterizam um

procedimento de busca local.

4.2.4 GERAÇÃO DE PADRÃO DE CORTE NO ALGORITMO G2D

Um padrão de corte é obtido numa subrotina da primeira versão do G2D que inicia

com os procedimentos de construção e de melhoria das faixas guilhotinas sendo executados

em sequência e termina quando não houver mais item em I com demanda positiva que puder

ser produzido no S corrente, isto é, fazendo I = ∅. Com os parâmetros de entrada do

GeraPadraoCorte já declarados anteriormente, conforme descrito a seguir, este procedimento

retorna uma solução y do PCBGR e seu valor de utilidade total Zy = ∑ g�(x).� � y.

Procedimento GeraPadraoCorte (I, y, α, S) 1. Enquanto (|I| > 0) faça 2. Execute ConstruçãoFaixa (I, y, α, S); 3. Execute MelhoriaFaixa (I, y, S, FH, yH, SH, FV, yV, SV); 4. Atualize I; 5. Calcule Zy; 6. Retorna (y, Zy);

Fim GeraPadraoCorte

TABELA 4.1 – Instância de Christofides e Whitlock Adaptada.

Para exemplificar a geração de um padrão de corte rotacionado, a instância clássica

ChW1 de Christofides e Whitlock (1977), com o total de itens m = 7 e o objeto de dimensões

C = 15 e L = 10, é adaptada para a variante sem peso, isto é, o valor dos itens vi passa a

i di (ci, li) vi

1 1 (2, 1) 2 2 2 (3, 2) 6 3 2 (3, 3) 9 4 5 (3, 4) 12 5 3 (8, 2) 16 6 1 (3, 7) 21 7 2 (8, 4) 32

54

corresponder à medida de sua área. Na Tabela 4.1, suas colunas trazem informações sobre

índice, demanda, dimensões e valor dos respectivos itens xi.

Adotando o parâmetro α = 0.1, primeiramente, assume-se I possuindo todos os 7

itens, os vetores y, yH e yV nulos e S = (15, 10). Inicia-se então a fase de construção, obtendo

β = 32 e LRC = {x2, x3, x4, x5, x6, x7}. Sendo o item x2 escolhido aleatoriamente em LRC,

uma nova escolha decide pela orientação p2 = (3, 2). A Figura 4.4 (a) apresenta as faixas

FH = (15, 2) e FV = (3, 10) iniciais, descritas a princípio por H2P2 e V2P2, ambas com a

quantidade de itens yH2 = yV2 = 2 determinada por sua demanda d2 = 2. Definidos, também, os

subretângulos SH = (15-6, 2) = (9, 2) e SV = (3, 10-4) = (3, 6), a fase de melhoria começa com

BH = {p5, r1} e BV = {p1, p3, p4, r1, r3}. Na melhoria da FH, a escolha do item r1 promove as

seguintes mudanças em yH1 = d1 = 1, SH = (9-1, 2) = (8, 2) e BH = {p5}. Essa última escolha

aconteceu porque r1 e p5 têm medidas iguais de largura. Como BH é unitário, isto indica que a

melhoria de FH continua com a inserção do item p5 e as atualizações são yH5 = [[8/8]] = 1,

SH = (8-8, 2) = (0, 2) e BH = ∅. Com BH vazio, dá-se início a melhoria na faixa FV e a escolha

do item p4 em BV resulta nas modificações em yV4 = [[6/4]] = 1, SV = (3, 6-4) = (3, 2) e

BV = {p1, r1}. Essa fase se encerra com a inclusão do item p1 e, consequentemente, com as

alterações yV1 = d1 = 1, SV = (3, 2-1) = (3, 1) e BV = ∅. A Figura 4.4 (a), também, ilustra as

modificações realizadas nas respectivas faixas pela fase de melhoria, H2P2M1R1M1P5 e

V2P2M1P4M1R1. Como perdaint(FH) = 0 é inferior a perdaint(FV) = 4/30 = 0.13, o vetor

solução y = y + yH e S = (15, 10-2) = (15, 8) e I = {x3, x4, x5, x6, x7} são atualizados com a

presença desta FH na composição do padrão de corte.

FIGURA 4.4 – Geração de Faixas Guilhotinas Horizontais e Verticais com Algoritmo G2D.

Geração de Faixas Guilhotinas

(a) (b)

55

Para o subretângulo corrente S = (15, 8), mantém-se β = 32. Um sorteio na nova

LRC = {x3, x4, x5, x6, x7} define que o item x7, com orientação p7, é responsável pelas novas

faixas FH = (15, 4) e FV = (8, 8) e pela atualização dos vetores nulos yH e yV, modificando-os

em yH7 = [[15/8]] = 1 e yV7 = d7 = 2, além dos subretângulos SH = (7, 4) e SV = (8, 0). No

processo de melhoria da FH, o item p4 é selecionado em BH = {p3, p4, r3, r4, r6} por ter maior

largura. Isso acarreta em yH4 = [[7/3]] = 2, SH = (7-6, 4) = (1, 4) e BH = ∅. Observe na Figura

4.4 (b) a ilustração desses passos, indicados pelas sequências por H1P7M2P4 e V2P7, sem a

melhoria da FV, pois SV = (8, 0) resulta em BV = ∅. A inclusão da FV no padrão de corte se

deve ao seu valor de perda interna menor que perdaint(FH) = 4/60 = 0.07.

FIGURA 4.5 – Geração de Faixas Guilhotinas Horizontais e Verticais com Algoritmo G2D.

Posteriormente as atualizações de y = y + yV, S = (15-8, 8) = (7, 8) e I = {x3, x4, x5,

x6}, inicia-se a nova fase de construção, fazendo yH e yV nulos e calculando β = 21, para

construir a LRC = {x3, x4, x5, x6}. Sendo x4 escolhido na orientação p4, as respectivas

alterações em yH4 = [[7/3]] = 2 e yV4 = [[8/4]] = 2 produzem as faixas FH = (7, 4) e FV = (3, 8)

e suas perdas internas SH = (3, 0) e SV = (1, 4), conforme observado na Figura 4.5 (a). Com

BH e BV ambos vazios e a perdaint(FH) = 4/21 = 0.19, decide-se então pela FV com

perdaint(FV) = 0 para composição do agora padrão de corte H2P2M1R1M1P5 V2P7 V2P4.

Dessa forma, é necessário registrar os incrementos com as modificações em y = y + yV e

S = (7-3, 8) = (4, 8).

Esse processo finaliza com a escolha do item r5 na última LRC, e a decisão entre as

faixas indicadas por H2R5 e V1R5 se deu por sorteio, pois ambas possuem perdaint(FH) =

perdaint(FV) = 0. Nesse caso, o vetor nulo yH é atualizado na posição yH5 = [[4/2]] = 2 e

Geração de Faixas Guilhotinas

(a) (b)

56

y = y + yH. Na Figura 4.5 (b) é possível verificar, com a sequência de decisões tomadas, que o

arranjo destas faixas produz o padrão de corte ótimo representado pelos caracteres

H2P2M1R1M1P5 V2P7 V2P4 H2R5.

4.2.5 ALGORITMO G2D

Sendo utilizado de forma concomitante na resolução dos problemas em destaque

PCBGR e PCEBG, ambos no caso não estagiado, sem peso e rotacionado, o algoritmo G2D

original inicia com o parâmetro α e o número de iterações maxiter pré-estabelecidos e sem

testes preliminares. Onde, a cada iteração, uma sequência de n padrões de corte é gerada,

atualizando sua demanda padrão a padrão, para compor uma solução Y = {y1, y2,..., yn} do

PCEBG. Ao final, o algoritmo, além de retornar o melhor padrão y* obtido para o PCBGR e

seu valor Zy*, produz uma solução de boa qualidade Y* para o PCEBG, com o total de objetos

utilizados ZY* para atender estritamente sua demanda. O pseudocódigo do G2D é apresentado

como segue.

Algoritmo G2D (α, maxiter) 1. Y* = ∅, ZY* = 0, y* = 0, Zy* = 0; 2. Para (Iter = 1, 2,..., maxiter) faça 3. Y = ∅, ZY = 0, n = 1; 4. I ← {x1,..., xm}; 5. Enquanto (|I| > 0) faça 6. �� = 0, S = R; 7. Execute GeraPadraoCorte (I, ��, α, S); 8. Se (Zy* < Zy) então 9. Atualize melhor solução do PCBGR, y* ← �� e Zy* ← Zy; 10. Atualize solução corrente do PCEBG, Y ← Y U{��} e ZY ← n; 11. Atualize I = {xi; di - ∑ ��

��� � > 0}e n ← n + 1;

12. Se (ZY * > ZY) então 13. Atualize melhor solução do PCEBG, Y* ← Y e ZY* ← ZY; 14. Retorna (Y*, ZY*, y*, Zy*);

Fim G2D

É importante ressaltar, ainda, que os percentuais de aproveitamento calculados nas

funções objetivo da versão original são equivalentes ao somatório do valor de utilidade de

cada item produzido na solução do PCBGR e ao total de objetos necessários no atendimento

da demanda do PCEBG, respectivamente. Isso acontece apenas na variante em que o valor do

item é sua medida de área, isto é, vi = ga(xi). Nesse caso, a melhor solução é aquela que

apresenta maior percentual de aproveitamento do objeto. Por exemplo, o padrão de corte

ilustrado na Figura 4.5 (b) apresenta aproveitamento total do objeto porque Zy* = ga(x1) +

2ga(x2) + 2ga(x4) + 3ga(x5) + 2ga(x7) = ga(R) = 150. Com as novas versões do algoritmo G2D

também abordando a variante que o valor do item pode distinguir da sua medida de área, é

57

necessário que a formulação da função objetivo diferencie da proposta original, sendo

modificada para retornar o valor de utilidade total Zy = ∑ v.� � y, dos itens relacionados no

padrão de corte y.

4.3 ALGORITMOS G2Da e G2Dv

Em (VELASCO; UCHOA, 2014b) foram realizadas as primeiras modificações na

versão original que culminaram nos algoritmos G2Da e G2Dv. Estes novos algoritmos tratam

exclusivamente dos respectivos casos do PCBGR sem peso e com peso, ambos com

impedimento de rotação dos itens. A versão G2Da é usada quando o valor de utilidade vi,

associado a cada item xi, é igual a sua medida de área. Se o conjunto I possui algum item xi tal

que vi ≠ ci.li, a versão utilizada é chamada G2Dv. Basicamente, a distinção entre essas novas

abordagens consiste na maneira pela qual é determinado o valor de utilidade de cada item e na

formação da LRC. As diferentes estratégias e modificações feitas no G2D original são:

i) O parâmetro pitens é o valor percentual responsável por interromper a geração de

padrões de corte para o conjunto Y, impondo um limite máximo ao número de itens com

demanda ainda não atendida. Com os novos algoritmos empenhados em resolver somente o

PCBGR, a cada padrão gerado e atualização do conjunto I, o algoritmo G2D é modificado na

linha 5 e passa a verificar se |I| ≤ (pitens.m). Por exemplo, se m = 50 e pitens = 0.9, então

|I| ≤ 45 indica que novos padrões são gerados até atender a demanda de 10% desses m itens;

ii) O valor das faixas horizontais e verticais deixa de ser atribuído ao percentual de

perda interna e é calculado simplesmente pela medida de área improdutiva. Para exemplificar,

o valor da faixa vertical observada na Figura 4.4 (a) muda para perdaint(FV) = 4;

iii) O parâmetro φ atua diretamente na fase de construção das faixas guilhotinas,

possibilitando a repetição de faixas completamente homogêneas em algumas iterações pré-

estabelecidas;

iv) Um novo movimento indicado pela letra A é proposto para fase de melhoria. A

estratégia consiste em escolher do conjunto BH o item de maior comprimento para compor a

faixa horizontal em formação. De forma análoga, um item de maior largura em BV deve ser

utilizado para valorizar a faixa vertical corrente;

v) Uma diferente formulação da LRC é proposta para o algoritmo G2Dv, utilizado na

resolução da variante com peso do PCBGR. Como o valor de utilidade dos itens pode diferir

de sua medida de área, é necessário que haja uma avaliação dessas grandezas de forma

multiobjetiva.

58

Por apresentarem maiores detalhes e serem providenciais nos resultados obtidos

nessas novas versões do G2D, as ampliações descritas nos itens iii), iv) e v) são explicadas nas

próximas subseções.

4.3.1 PARÂMETRO φ E REPETIÇÃO DE FAIXAS HOMOGÊNEAS

Se as faixas FH e FV, construídas de forma sequencial, depois de extraído um item xk

na LCR, não apresentam perda interna, essas podem ser repetidas em quantidades que não

extrapolem as dimensões de S = (CS, LS) nem violem a demanda atual. O parâmetro φ

determina a frequência de iterações que admitem tais repetições no padrão de corte presente.

Se a iteração corrente Iter é múltipla de φ, o número de repetições destas faixas homogêneas

FH e FV é dado por numFH = min {[[LS/lk]], [[dk-yk/yHk]]} e numFV = min {[[CS/ck]],

[[dk-yk/yVk]]}, respectivamente.

O padrão de corte da Figura 4.6 é o ótimo da instância clássica CU2, do PCBGR sem

peso (HIFI, 2004b), e seu valor de utilidade total é 26100. É possível verificar nesse padrão a

existência de numFH = [[8/3]] = 2 faixas horizontais homogêneas idênticas e perfeitas, cada

uma com três itens p30 = (50, 45). Certamente, estas podem ser produzidas pelo G2Da, de

forma mais eficiente devido ao uso do parâmetro φ, com a solução dessa instância

representada por H3P30H3P30 H1P25M2P30 H2P28.

FIGURA 4.6 – Padrão de Corte Ótimo da Instância CU2 com Repetição de Faixas Homogêneas.

Com a ampliação que utiliza o parâmetro φ, o procedimento ContruçãoFaixa além de

receber também os parâmetros φ e Iter, acrescenta após a linha 6 o novo procedimento

RepetiçãoFaixa. Observe no pseudocódigo a seguir que, se houver possibilidade de repetição

Padrão de Corte Ótimo CU2 com Repetição de Faixas Homogêneas

59

de faixas, as novas atualizações consistem em: FH = (CFH, numFH.LFH), yH = yH.numFH,

SH = (0, numFH.LH), FV = (numFV.CFV, LFV), yV = yV.numFV e SV = (numFV.CV, 0).

Procedimento RepetiçãoFaixa (FH, yH, FV, yV, Iter, φ) 1. Se (MOD(Iter, φ) = 0) então 2. Se (perdaint(FH) = 0) então 3. Calcule numFH; 4. Atualize FH, yH e SH; 5. Se (perdaint(FV) = 0) então 6. Calcule numFV; 7. Atualize FV, yV e SV;

Fim RepetiçãoFaixa

4.3.2 MOVIMENTO DE MELHORIA A

Ao contrário do movimento de melhoria indicado por M, a presença da letra A em

uma solução, representada por uma sequência de caracteres iniciadas por H ou V, estabelece

que o item escolhido para compor uma das faixas FH ou FV possui maior comprimento em BH

ou maior largura em BV, respectivamente. Ainda se houver mais itens com a mesma

dimensão, a seleção deve ser aleatória nesses conjuntos. A Figura 4.7 ilustra algumas faixas

guilhotinas com a aplicação da melhoria A.

FIGURA 4. 7 – Faixas Guilhotinas Horizontais e Verticais com Melhoria A.

É importante destacar que as estratégias de movimento no algoritmo G2Da são usadas

separadamente para produzir duas configurações de faixas guilhotinas horizontais e duas

verticais, representadas pelos vetores m-dimensionais auxiliares yHM, yHA, yVM e yVA.

Sendo SH = (CSH, LSH) e SV = (CSV, LSV) os respectivos subretângulos tratados como

perda interna das faixas FH e FV, provenientes da fase de construção, e os conjuntos BH e BV

redefinidos, na presente subseção para o PCBGR sem rotação dos itens, por

H3P1A1P5A1P3

P5

P3

H3P1A2P6

P1 P1 P1 P6

P6

Faixas Guilhotinas com Melhoria A

V2P2A1P7A1P4

P2

P7 P4

P2

P1 P1 P1

60

BH = {xi ∈ I | (di-yHi > 0) e (ci ≤ CSH e li ≤ LSH)} e

BV = {xi ∈ I | (di-yVi > 0) e (ci ≤ CSV e li ≤ LSV)}.

O procedimento MelhoriaFaixa passa a ser desmembrado em outros dois, chamados

de MelhoriaFaixaH e MelhoriaFaixaV, pois as estratégias assinaladas por M ou A são

utilizadas separadamente no processo de melhoria das faixas FH e FV. Dessa forma, na

abordagem dos novos procedimentos, se faz necessário à utilização de alguns elementos

complementares como segue. Os vetores yHM, yHA, yVM e yVA são inicialmente preenchidos

com os respectivos dados da fase de construção de yH e yV. Assim como, SHM, SHA, SVM e SVA

recebem as dimensões do subretângulo residual SH. Já os conjuntos BHM e BHA são

inicializados com os elementos de BH e, BVM e BVA com os pertencentes à BV. Os

procedimentos em destaque são apresentados na sequência.

Procedimento MelhoriaFaixaH (I, FH, yH, SH, BH) 1. yHM = yHA = yH, SHM = SHA = SH, BHM = BHA = BH; 2. Enquanto (|BHM| ≠ 0) faça 3. Selecione xj’ de BHM com maior largura, para usar “M”; 4. Atualize yHM, SHM e BHM; 5. Enquanto (|BHA| ≠ 0) faça 6. Selecione xj’’ de BHA com maior comprimento, para usar “A”; 7. Atualize yHA, SHA e BHA; 8. Determine perdaint(FH) = min {perdaint(FHM), perdaint(FHA)}; 9. Atualize yH relacionado à perdaint(FH); 10. Retorna (yH, perdaint(FH));

Fim MelhoriaFaixaH

No pseudocódigo MelhoriaFaixaH, a melhoria M da faixa horizontal inicia-se com a

escolha do item xj’ de BHM, de acordo com sua largura, em quantidade yHMj’ = min{dj’-yj’,

[[CSH/cj’]]}, seguido das atualizações SHM = (CSH-yHMj’.cj’, LSH) e de BHM. Assim como, o

movimento indicado por A começa com a seleção do item xj’’ de maior comprimento em BHA,

com os incrementos sendo renovados continuamente em yHAj’’ = min{dj’’-yj’’, [[LSH/lj’’]]},

SHA = (CSH, LSH-yHAj’’.lj’’) e BHA. Com o objetivo de minimizar as perdas internas nos

subretângulos SHM e SHA, este processo é repetido até não existir mais itens em BHM e BHA,

finalizando com yH atualizado por apenas um dos vetores yHM ou yHA, escolhido pelo critério

menor percentual de perda interna apresentado. Para então, posteriormente, executar o

Procedimento MelhoriaFaixaV.

Procedimento MelhoriaFaixaV (I, FV, yV, SV, BV) 1. yVM = yVA = yV, SVM = SVA = SV, BVM = BVA = BV; 2. Enquanto (|BVM| ≠ 0) faça 3. Selecione xt’ de BVM com maior comprimento, para usar “M”; 4. Atualize yVM, SVM e BVM; 5. Enquanto (|BVA| ≠ 0) faça

61

6. Selecione xt’’ de BVA com maior largura, para usar “A”; 7. Atualize yVA, SVA e BVA; 8. Determine perdaint(FV) = min {perdaint(FVM), perdaint(FVA)}; 9. Atualize yV relacionado à perdaint(FV); 10. Retorna (yV, perdaint(FV));

Fim MelhoriaFaixaV

Equivalente ao procedimento anterior, o MelhoriaFaixaV produz melhorias do tipo

M ou A, nas faixas verticais anotadas nos vetores yVM e yVA, até que os conjuntos BVM e

BVA, com as mesmas características de BV, apresentem cardinalidade zero, respectivamente.

Com a melhoria promovida pelo mais comprido item xt’ de BHM, as atualizações são

yVMt’ = min{dt’-yt’, [[LSH/lt’]]}, SVM = (CSH, LSH-yVMt’.lt’) e BVM. Na inclusão do item xt’’ de maior

largura em BVA, os aperfeiçoamentos registrados são yVAt’’ = min{dt’’-yt’’, [[CSH/ct’’]]}, seguido

das atualizações SVA = (CSH-yVAt’’.ct’’, LSH) e de BVA. O presente processo finaliza com yV

atualizado pela faixa de menor perda interna entre yVM e yVA.

A execução dos procedimentos MelhoriaFaixaH e MelhoriaFaixaV, nessa ordem,

são consideradas pelo novo MelhoriaFaixa, conforme apresentado no pseudocódigo seguinte.

Sendo que, ao final, espera-se ter produzido quatro configurações distintas de faixas

guilhotinas e, então, aproveitar a faixa com o menor valor de perda interna na composição do

padrão de corte corrente. Considerando a possibilidade de acontecer empate nos valores

perdaint(FH) e perdaint(FV), a escolha da faixa a ser registrada em y e configurar no padrão de

corte é aleatória.

Procedimento MelhoriaFaixa (I, y, S, FH, yH, SH, FV, yV, SV) 1. Crie BH e BV; 2. Se (|BH| ≠ 0) então 3. Execute MelhoriaFaixaH (I, FH, yH, SH, BH); 4. Se (|BV| ≠ 0) então 5. Execute MelhoriaFaixaV (I, FV, yV, SV, BV); 6. Determine perdaintFmelhor = min {perdaint(FH), perdaint(FV)}; 7. Atualize y e S relacionado à perdaintFmelhor; 8. Retorna (y, S);

Fim MelhoriaFaixa

O padrão de corte exposto na Figura 4.8 é o ótimo da instância clássica OF1, com

valor de utilidade total 2737 (OLIVEIRA; FERREIRA, 1990). Esta solução apresenta cinco

faixas guilhotinas que podem ser descritas como V2P8 V1P2 H1P8A1P7A1P1 V1P6 H2P5

H1P10. Observe que a faixa guilhotina horizontal apresenta ações da melhoria A. É

necessário destacar que sem essa ampliação, considerando apenas a melhoria M, o melhor

padrão produzido é H3P8M2P5 V1P6 V1P6 V1P6 e possui valor 2713.

.

62

FIGURA 4.8 – Padrão de Corte Ótimo da Instância OF1 com Melhorias M e A.

4.3.3 PSEUDOCÓDIGO DO ALGORITMO G2Da

Sendo o algoritmo G2Da utilizado para resolver instâncias do PCBGR sem rotação e

cujo valor dos itens corresponde a sua medida deárea, este retorna ao final da sua execução o

algoritmo a melhor solução y* obtida para o problema em questão e seu valor de utilidade

total Zy*. Antes de apresentar um pseudocódigo para tal ampliação, pretende-se mostrar as

informações referentes aos dados do problema, de entrada e suas variáveis que são

reconsideradas para o melhor entendimento desse algoritmo. Em relação aos dados do

problema tem-se:

� m : total de itens demandados;

� xi : item i sem orientação pré-estabelecida a ser produzido;

� ci : comprimento do item i;

� li : largura do item i;

� di : demanda do item i a ser atendida;

� vi : valor de utilidade do item i;

� R : objeto retangular em estoque, de comprimento C e largura L;

� S : subretângulo resultante de um corte guilhotinado que define uma faixa em R.

No que se refere aos parâmetros, estes são:

� α : parâmetro que controla o grau de miopia e aleatoriedade da fase de construção;

� maxiter : número máximo de iterações;

� pitens : valor percentual do número de itens utilizados na geração dos padrões;

� φ : parâmetro que determina as iterações com repetição de uma faixa homogênea.

Padrão de Corte Ótimo OF1 com Melhorias M e A

63

As variáveis relacionadas na codificação deste algoritmo são apresentadas a seguir.

� I : conjunto de itens xi candidatos a compor uma solução;

� β : item xi de maior área em I;

� LRC : lista restrita composta pelos melhores itens de I;

� y : padrão de corte corrente;

� Zy : valor de utilidade total do padrão de corte corrente;

� y* : melhor padrão de corte;

� Zy* : valor de utilidade total do melhor padrão de corte.

Em seguida, descreve-se o pseudocódigo do algoritmo G2Da.

Algoritmo G2Da (α, maxiter, pitens, φ) 1. y

* = 0, Zy* = 0;

2. Para (Iter = 1, 2,..., maxiter) faça 3. I ← {x1,..., xm}; 4. Enquanto (|I| ≤ pitens.m) faça 5. y = 0, S = R; 6. Execute GeraPadraoCorte (I, y, α, S, φ); 7. Se (Zy

* < Zy) então 8. Atualize melhor solução do PCBGR, y* ← y e Zy

* ← Zy; 9. Atualize I = {xi; di - ∑ ��

��� � > 0};

10. Retorna (y*, Zy*);

Fim G2Da

4.3.3 LISTA RESTRITA DE CANDIDATOS DO G2Dv

O algoritmo G2Dv utiliza praticamente os mesmos alicerces empregados na

arquitetura do G2Da, diferenciando-se apenas no modo que se constitui a LRC e as

modificações necessárias nas linhas 2 e 3 do pseudocódigo ConstruçãoFaixa são descritas a

seguir.

Primeiramente, é importante ressaltar que os itens das instâncias utilizadas nos testes

com o algoritmo G2Dv apresentam valor de utilidade vi, associado a cada item xi, não

necessariamente igual à sua medida de área. Isto é, deve existir pelo menos um item xi tal que

vi ≠ ci.li.

A mudança na concepção da LRC se deve a escolha aleatória do item xk que define a

criação das faixas FH e FV. Passa-se a considerar, simultaneamente, as grandezas medida de

área e valor de utilidade. Utilizando os elementos da LRC tradicional do G2Da, denominada

LRCa, o processo de formação da nova LRCv se estabelece com mais dois elementos:

i) A função gulosa gv: I → ℝ, onde gv(xi) = vi é o valor de utilidade de cada item de

I;

64

ii) O critério guloso βv = max {gv(xi); xi ∈ LRCa} que retorna o maior valor de

utilidade entre os itens de LRCa.

Então, define-se LRCv = {x ∈ LRCa | α.βv ≤ gv(x) ≤ βv} com os itens de LRCa que

apresentam os maiores valores de utilidade e sua cardinalidade é determinada pelo parâmetro

α ∈ [0,1].

A Figura 4.9 apresenta o padrão de corte ótimo gerado pelo G2Dv para a instância

clássica ChW1 (CHRISTOFIDES; WHITLOCK, 1977). Com valor 244 e representação

V2P7M1P5 V1P6A1P3 V2P4M1P2, este padrão apresenta 10/150 = 0.07 de perda interna em

relação à área do objeto. Para justificar a mudança feita na LRC do algoritmo G2Dv, evidencia-

se a distinção entre as listas LRCa e LRCv na execução deste algoritmo. A utilização da LRCa

no G2Dv retorna o padrão V1P6A1P3 H4P4 V1P7M1P5 V1P4A1P2, de perda interna 6/150 =

0.04 para ChW1. Entretanto, optando produzir mais itens p4 ao invés de p7, este padrão tem

valor de utilidade total 229. Assim, considera-se importante que haja uma ponderação entre o

valor de utilidade dos itens e sua medida de área ao tratar o caso com peso do PCBGR.

FIGURA 4.9 – Padrão de Corte Ótimo da Instância ChW1 com Algoritmo G2Dv.

4.4 ALGORITMOS G2D REATIVOS

Com o valor empregado ao parâmetro α e o critério de seleção da faixa a compor o

padrão de corte exercendo forte influência nos resultados dos algoritmos G2Da e G2Dv e

propensos a calibração, as novas extensões do G2D são inspiradas no método GRASP Reativo

proposto por Prais e Ribeiro (2000). As ampliações reativas do G2D original, denominadas

RG2Da, RG2Dv, RG2Dar e RG2Dvr são destinadas a resolução das variantes do PCBGR que se

distinguem pelo valor do item e também consideram a possibilidade de rotação (ar ou vr) para

Padrão de Corte Ótimo ChW1

65

ambos os casos. A implementação do algoritmo genérico RG2D considerado na presente

subseção apresenta duas etapas distintas, chamadas de fase de calibragem e fase reativa. A

eficiência de tais versões pode ser verificada na qualidade de suas soluções, totalizando o

melhor resultado em 7 instâncias, incluindo mais 4 ótimos, se comparado com os resultados

produzidos em (VELASCO; UCHOA, 2014b) nas 30 instâncias consideradas clássicas. A

seguir são destacadas as inovações e diferentes alterações utilizadas na arquitetura dessas

versões reativas do G2D:

i) No ajuste do parâmetro α realizado na fase de calibragem, inicialmente, considera-

se um conjunto finito Α de valores no intervalo [0, 1], pré-definidos de acordo com as

características do problema. Com uma aprimorada calibragem após um determinado número

de iterações iterC, define-se o alfa reativo αR como aquele que apresenta com maior frequência

a melhor solução. Na fase seguinte, um novo conjunto A’ é criado, a partir de incrementos e

decrementos de valores constantes realizados na mediana αR. Com Α’ assim definido, o

algoritmo ainda deve ser executado iterR iterações para cada valor de α ∈ A’.

ii) O critério guloso βv é redefinido nos algoritmos RG2Dv e RG2Dvr de forma que a

LRCv seja formada pelos itens que apresentam as maiores razões entre o valor de utilidade e

sua medida de área. Sejam as funções gv(x) e ga(x) responsáveis por retornar os respectivos

valores de utilidade e de medida de área de um item x, então βv = max {gv(xi)/ga(xi);

xi ∈ LRCa} determina o índice de maior valor para composição da LRCv = {x ∈ LRCa | α.βv ≤

gv(x) ≤ βv}. É importante destacar que a diferença entre os algoritmos supracitados e seus

correspondentes RG2Da e RG2Dar, do caso sem peso do PCBGR, limita-se apenas ao modo

como é constituída a LRC.

iii) Para intensificar as ações da fase de melhoria, os subretângulos de perda interna

SDH e SDV, definidos como dentes e gerados nas respectivas faixas guilhotinas a partir da

inclusão dos itens oriundos dos movimentos de melhoria M ou A, são aproveitados em novas

ações de melhoria denotadas com as letras m e a. Análogo ao propósito dos conjuntos BH e

BV, os conjuntos DH e DV são constituídos dos itens de I com demanda não atendida e que

viabilizam o corte guilhotinado nos respectivos dentes SDH e SDV. Para este procedimento,

também é estabelecido o parâmetro δ, responsável pela frequência de iterações que permitem

a recuperação dos dentes.

iv) É introduzido o parâmetro psi (ψ) como o percentual de perda aceitável de uma

faixa inserida no padrão de corte. Com as quatro faixas guilhotinas resultantes da fase de

melhoria FHM, FHA, FVM, e FVA, define-se FMin como a faixa guilhotina de menor valor

percentual de perda interna. Com a inclusão destes elementos, institui-se a Lista Restrita de

66

Faixas (LRF) como um conjunto das próximas faixas candidata a compor o padrão de corte

corrente. Vale ressaltar que, assim como o parâmetro α, o novo parâmetro ψ deve ser ajustado

na fase de calibragem a partir de um conjunto finito Ψ de valores pré-estabelecidos.

Nas subseções seguintes, as propostas de inovação para fase melhoria, citadas nos

itens iii) e iv), e o pseudocódigo genérico do algoritmo RG2D é apresentado com a devida

importância.

4.4.1 PARÂMETRO δ E DENTES DAS FAIXAS GUILHOTINAS

Ainda sobre a inserção de novos itens na fase de melhoria, em movimentos indicados

pelas letras M ou A, estes podem não fazer o uso dessas faixas guilhotinas em sua totalidade.

Considerando que no processamento de tais faixas, com dimensões definidas por xk = (ck, lk) e

por algum subretângulo de perda interna SH = (CSH, LSH) ou SV = (CSV, LSV), a inclusão de

certas quantidades de cada item selecionado a partir de uma única dimensão relevante, largura

ou comprimento, dos respectivos conjuntos BHM BHA BVM e BVA, pode originar um

subretângulo residual no interior da faixa, possivelmente reaproveitável, denominado dente.

Na Figura 4.10(a), deve-se observar que os três itens p2 = (c2, l2), escolhidos após o

movimento M, produziram um dente de comprimento 3c2 igual ao triplo do comprimento

deste item. Já sua largura é igual à diferença entre as larguras da faixa e de p2, isto é, LSH-l2.

Ainda nesta Figura e de forma análoga, o dente gerado pelo único item p6 tem comprimento

igual ao deste item e sua largura é dada pela diferença das larguras da faixa e do item p6.

FIGURA 4.10 – Faixas Guilhotinas Horizontais e Reaproveitamento de Dentes.

Dentes em Faixas Guilhotinas Horizontais

(a) H2P1M3P2M1P6

(b) H2P1M3P2a2P4M1P6m3P5

67

Os dentes determinados em faixas guilhotinas verticais ganham evidência na Figura

4.11(a). Na sequência do movimento A, o primeiro dente tem comprimento igual a 2c3 e

largura calculada por LSV-l3. Enquanto no segundo dente, o dobro comprimento do item r4 =

(l4, c4) define seu comprimento 2l4 e a diferença entre as respectivas medidas de largura LSV-c4

passa a ser a outra dimensão do dente.

No reaproveitamento dos dentes são utilizadas as letras minúsculas m e a em novas

expressões, indicando o acréscimo de movimentos de melhoria realizado de forma

equivalente as indicadas por M e A, respectivamente. Estas novas ampliações no G2D podem

ser conferidas nas Figuras 4.10(b) e 4.11(b), com as respectivas FH e FV representadas por

H2P1M3P2a2P4M1P6m3P5 e V2R1A2P3a1P2A2R4m2P5.

Com os movimentos de melhoria indicados por M e A gerando perdas internas que

ainda possam ser reaproveitadas, as novas ações propostas objetivam o melhor

aproveitamento nos dentes genéricos SDH = (CDH, LDH) e SDV = (CDV, LDV), das faixas FH e FV,

nessa ordem. Sendo o custo computacional elevado, na aplicação desse procedimento em

todas as faixas guilhotinas produzidas, opta-se apenas nas iterações múltiplas do parâmetro δ

para realização das ações descritas como segue.

FIGURA 4.11 – Faixas Guilhotinas Verticais e Reaproveitamento de Dentes.

Derivando da estrutura dos conjuntos BH e BV, os conjuntos DH = {xi ∈ I | (di-yHi > 0)

e ((ci ≤ CDH e li ≤ LDH) ou (li ≤ CDH e ci ≤ LDH))} e DV = {xi ∈ I | (di-yVi > 0) e ((ci ≤ CDV e

Dentes em Faixas Guilhotinas Verticais

(a) V2R1A2P3A2R4 (b) V2R1A2P3a1P2A2R4m2P5

68

li ≤ LDV) ou (li ≤ CDV e ci ≤ LDV))} são constituídos dos itens com demanda não atendida, que

garantam o corte guilhotinado nos respectivos dentes SDH e SDV. Destaca-se que os conjuntos

DH e DV estão definidos para o caso rotacionado do PCBGR.

Sintetizando a nova fase de melhoria em uma faixa horizontal, a cada uma das

estratégias assinaladas por M ou A, calculam-se individualmente os números yHMj’ e yHAj’’ de

itens xj’ e xj’’ a serem incluídos nos subretângulos SHM = (CSHM, LSHM) e SHA = (CSHA, LSHA). A

partir disto, admitindo que xj’ = (cj’, lj’) e xj’’ = (cj’’, lj’’) tenham às coordenadas das orientações

adotadas com os movimentos M e A e que os novos movimentos melhoria sejam realizados

no decorrer de uma iteração condicionada ao parâmetro δ, tem-se SDH = (yHMj’.cj’, LSHM-lj’) ou

SDH = (CSHA-cj’’, yHAj’’.lj’’) definidos como os respectivos dentes gerados na inclusão dos itens xj’

e xj’’. Análoga às anteriores, as ações de melhoria apresentadas a seguir, são realizadas

separadamente nos dentes estabelecidos em cada movimento designado pelas letras M e A.

Analisando apenas o dente SDH gerado após a melhoria M com o item xj’, o processo

começa considerando também a formação do conjunto de itens DH. A seguir, com os vetores

auxiliares m-dimensionais yDm e yDa inicializados nulos, decide-se pela inclusão do próximo

item pertencente ao conjunto DH, com xw’ escolhido por apresentar maior largura e xw’’ o

maior comprimento, nas quantidades yDmw’ = min{dw’-yw’, [[CDH/cw’]]} e yDaw’’ = min{dw’’-yw’’,

[[LDH/lw’’]]}, em ações denotadas pelas respectivas letras minúsculas m e a. Buscando o

melhor aproveitamento do dente atual e consequentemente da faixa FH corrente, o movimento

que apresentar menor percentual de perda interna perdaint(SDH) no correspondente SDH,

escolhido entre os valores perdaint(SDHm) = (ga(SDH)-∑ g�(x).� � y��)/ga(SDH) e perdaint(SDHa)

= (ga(SDH)-∑ g�(x).� � y��)/ga(SDH), determina a melhoria a ser aplicada no dente atual. Caso

haja empate entre esses valores de perda interna, a escolha deve ser aleatória. A seguir,

atualizam-se as dimensões deste dente conforme com a composição atribuída a perdaint(SDH),

assumindo SDH = (CDH-yDmw’.cw’, LDH) ou SDH = (CDH, LDH-yDaw’’.lw’’), juntamente com o conjunto

DH, até que este torne-se vazio.

O procedimento MelhoriaDenteH a seguir, descreve apenas a possibilidade de

reaproveitamento do dente SDH = (yHMj’.cj’, LSHM - lj’), depois da melhoria do tipo M utilizar

yHMj’ cópias do item xj’ na faixa horizontal. Entretanto, o reaproveitamento do dente

procedente de uma melhoria A na faixa vertical, com yHAj’’ itens xj’’ em SDH = (CSHA-cj’’,

yHAj’’.lj’’), é realizado de forma equivalente e difere apenas na passagem dos relativos

parâmetros yHA, SHA e BHA.

Procedimento MelhoriaDenteH (yHM, SHM, BHM) 1. Determine SDH;

69

2. Crie DH; 3. Enquanto (|DH| ≠ 0) faça 4. yDm = yDa = 0; 5. Selecione xw’ de DH com maior largura, para usar “m”; 6. Selecione xw’’ de DH com maior comprimento, para usar “a”; 7. Atualize yDm e yDa; 8. Determine perdaint(SDH) = min {perdaint(SDHm), perdaint(SDHa)}; 9. Atualize yHM, SDH e DH relacionado à perdaint(SDH); 10. Retorna (yHM);

Fim MelhoriaDenteH

As inovações na fase de melhoria de uma faixa vertical, com a inserção desses

movimentos representados nas letras m e a, são adaptadas de maneira semelhante as suas

aplicações na faixa horizontal. Calculando-se as quantidades yVMt’ e yVAt’’, de itens xt’ e xt’’,

após cada melhoria M e A em FV corrente, para acrescentá-los nos subretângulos SVM = (CSVM,

LSVM) e SVA = (CSVA, LSVA), em uma iteração múltipla de δ, determina-se os respectivos dentes

SDV = (CSVM-ct’, yVMt’.lt’) ou SDV = (yVAt’’.ct’’, LSVA-lt’’).

Considerando apenas a melhoria do subretângulo residuais SDV, gerado pela melhoria

M do item xt’, seleciona-se no conjunto DV o item xt’ de maior largura e o xt’’ de maior

comprimento, nas quantidades yDmt’ = min{dt’-yt’, [[LDV/lt’]]} e yDat’’ = min{dt’’-yt’’, [[CDV/ct’’]]}.

Desta seleção, escolhe-se o movimento que produza o menor percentual de perda interna no

SDV atual. Com a atualização ininterrupta dos dentes com valor positivo igual à perdaint(SDV),

fazendo SDV = (CDV-yDmt’.ct’, LDV) ou SDV = (CDV, LDV-yDat’’.lt’’), e consequentemente do conjunto

de itens DV, esse processo encerra-se quando |DV| = 0. Com o dente SDV = (CSVM-ct’, yVMt’.lt’)

em destaque, originado na melhoria M com o item xt’, apresenta-se a seguir o pseudocódigo

MelhoriaDenteV que retorna o vetor yVM atualizado dos itens de DV cortados no dente em

questão. É importante distinguir que no processo de reaproveitamento do dente resultante de

uma melhoria A na faixa vertical, com yVAt’’ itens xt’’ em SDV = (yHAt’’.ct’’, LSVA-lt’’), são

considerados os parâmetros yVA, SVA e BVA.

Procedimento MelhoriaDenteV (yVM, SVM, BVM) 1. Determine SDV; 2. Crie DV; 3. Enquanto (|DV| ≠ 0) faça 4. yDm = yDa = 0; 5. Selecione xt’ de DV com maior comprimento, para usar “m”; 6. Selecione xt’’ de DV com maior largura, para usar “a”; 7. Atualize yDm e yDa; 8. Determine perdaint(SDV) = min {perdaint(SDVm), perdaint(SDVa)}; 9. Atualize yVM, SDV e DV relacionado à perdaint(SDV); 10. Retorna (yVM);

Fim MelhoriaDenteV

70

As chamadas de execução dos procedimentos MelhoriaDenteH e MelhoriaDenteV

são realizadas internamente nos procedimentos MelhoriaFaixaH e MelhoriaFaixaV, logo após

as respectivas atualizações das linhas 4 e 7.

Certamente, a utilização dos respectivos procedimentos MelhoriaDenteH e

MelhoriaDenteV, que abordam o melhor tratamento das perdas internas relacionadas aos

subretângulos denominados dentes, em qualquer das quatro faixas guilhotinas produzidas na

fase de melhoria, acarretaria em considerável diversificação e aperfeiçoamento do processo de

composição dessas faixas, deixando o algoritmo G2D mais inteligente para escapar de padrões

de corte considerados ótimos locais. Para fins de ilustração, a Figura 4.12 apresenta uma

solução do PCBGR com a rotação e suas respectivas melhorias descritas na sequência

alfanumérica H1P8A1R4a2P5A1P6m2P9 V1P7A4P2 H1R3M1P2a1P5m1p1.

FIGURA 4.12 – Padrão de Corte com Reaproveitamento de Dentes.

4.4.2 PARÂMETRO ψ E LISTA RESTRITA DE FAIXAS

Assim como na versão inicial do algoritmo G2D, que também admite a rotação dos

itens, o valor da faixa guilhotina volta ser calculado pelo seu percentual de perda interna.

Sabendo que ao final de cada fase de melhoria com algoritmo G2D, tem-se produzida quatro

possíveis configurações distintas de faixas guilhotinas FHM, FHA, FVM e FVA. Define-se FMin

como a faixa guilhotina de menor valor percentual entre as faixas do conjunto F = {FHM, FHA,

FVM, FVA}. Seja ψ um parâmetro usado para delimitar o percentual de perda aceitável nas

faixas guilhotinas de uma solução do PCBGR. Se a diferença entre o valores das faixas

pertencentes ao conjunto F e de FMin não maior que ψ, esta faixa é incluída no conjunto

Padrão de Corte com Reaproveitamento de Dentes

71

chamado de Lista Restrita de Faixas (LRF). Assim como o parâmetro α da LRC, ψ também é

responsável pela cardinalidade de LRF = {f ∈ F | perdaint(f)-perdaint(FMin) ≤ ψ }, com a

próxima faixa a compor o padrão de corte atual sendo escolhida aleatoriamente deste

conjunto. É importante ressaltar que o parâmetro ψ reativo (ψR) não é arbitrário e também

deve ser calibrado a partir de um conjunto finito Ψ de valores pré-estabelecidos nas versões

do algoritmo RG2D.

/

FIGURA 4.13 – Padrão de Corte gcut13 com Reaproveitamento de Dentes e LRF.

O pseudocódigo seguinte, primeiramente, considera que os respectivos

procedimentos MelhoriaFaixaH e MelhoriaFaixaV são modificados para retornar os vetores

yHM, yHA, yVM e yVA, referentes às quatro faixas produzidas nessa fase. Tomando esses

vetores, o conjunto F e um valor pré-estabelecido de ψ como parâmetros de entrada, o

procedimento SeleçãoFaixa encarrega-se de fornecer uma faixa guilhotina a partir de uma

escolha aleatória na LRF. Esse procedimento deve substituir as linhas 6 e 7 no procedimento

MelhoriaFaixa.

Padrão de Corte gcut13 com Reaproveitamento de Dentes e LRF

P24

P22

P6

P25

P20

P19

P27

P28

P29

P30

P17

P18

P23

P9

P16

P26

P2

P1

72

Procedimento SeleçãoFaixa (yHM, yHA, yVM, yVA, F, ψ) 1. FMin ← min {perdaint(f); f ∈ F}; 2. LRF ← {f ∈ F | perdaint(f)-perdaint(FMin) ≤ ψ} 3. Escolha, aleatoriamente, fz de LRF; 4. Atualize y e S relacionado à fz; 5. Retorna (y, S);

Fim SeleçãoFaixa

Para exemplificar a utilização das ampliações em destaque nas subseções 4.4.1 e

4.4.2, a Figura 4.13 apresenta o melhor padrão de corte obtido com a versão mais recente do

G2Da para instância gcut13. Utilizando α = 0.2, ψ = 0.03 e o reaproveitamento de dentes, este

possui valor total de utilidade 8618394 e tem representação V1P22A1P24 V1P20A1P25m1P6

H1P30M1P9M1P2a1P1 V1P29M1P28M1P27M1P19 V1P23M1P18M1P17 V1P26M1P16.

Essa instância também é considerada clássica de uma variante dos Problemas de Corte e

Empacotamento, em que os itens apresentam demanda unitária e valor de utilidade igual à

medida de área, conhecida como Two-Dimensional Bin Packing Problem.

4.4.3 PSEUDOCÓDIGO GENÉRICO DO ALGORITMO RG2D

Diferentemente da proposta original do método GRASP Reativo (PRAIS; RIBEIRO,

2000), as versões do algoritmo RG2D consideram não somente a calibragem do parâmetro α

da LRC em sua fase de diversificação, mas também o ajuste do novo parâmetro ψ presente na

LRF. Nessa primeira fase, denominada de fase de diversificação, consideram-se os dois

conjuntos finitos Α e Ψ, de valores pertencentes ao intervalo [0, 1]. Esses conjuntos são pré-

definidos, de acordo com as características do problema, com os respectivos valores

atribuídos aos parâmetros α e ψ nessa fase de calibragem para determinação dos parâmetros

reativos αR e ψR. Para isso, em conformidade com a variante que se refere à instância e

incluindo as modificações em destaque nas subseções anteriores, executa-se um dos

algoritmos G2Da, G2Dar, G2Dv ou G2Dvr no total de iterC iterações, para cada par de combinação

de elementos de Α e Ψ. Nessa fase, esses algoritmos reativos retornam a solução y* de maior

frequência entre as que apresentam valor Zy* e sua frequência indicada por fαψ. Ao final dessa

etapa, o par de valores de α e ψ que obtém a solução de maior valor e maior frequência fαψ,

definem os parâmetros reativos da próxima fase. É importante relatar, ainda, que em caso de

empate das respectivas frequências, um sorteio estabelece os parâmetros que melhor se

adequam à instância.

Na fase posterior, denominada fase reativa, inicia-se com a determinação de um novo

conjunto A’ constituído de valores no entorno da mediana αR, estabelecendo acréscimos e

decréscimos a serem realizados nesse parâmetro reativo. Assim como na fase de

73

diversificação, executa-se nesta fase as ampliações do algoritmo G2D, com o total de iterR

iterações para cada combinação dos elemento de A’ e ψR pré-determinado, com o objetivo de

escapar possíveis ótimos locais e produzir um padrão de corte de melhor valor de utilidade

total.

Em seguida, o pseudocódigo com os passos do algoritmo RG2D expõe seu

desenvolvimento que tem os seguintes parâmetros:

� Α : conjunto dos valores do parâmetro α considerados na fase de diversificação;

� Ψ : conjunto dos valores do parâmetro ψ considerados fase de diversificação;

� iterC : número de iterações na fase de diversificação;

� iterR : número de iterações na fase reativa.

Algumas das variáveis utilizadas nesse pseudocódigo, também, recebem o devido

destaque como segue.

� αR : parâmetro α da melhor solução;

� ψR : parâmetro ψ da melhor solução;

� fαR : frequência da melhor solução para o valor αR corrente;

� α1 : parâmetro α corrente da fase de diversificação;

� ψ1 : parâmetro ψ corrente da fase de diversificação;

� fαψ : frequência da melhor solução com os parâmetros α e ψ correntes;

� Α’ : conjunto dos valores resultante do parâmetro αR considerados na fase reativa;

� α2 : parâmetro α corrente da fase reativa;

� y* : melhor padrão de corte do G2D, com α e ψ correntes;

� Zy* : valor de utilidade total do melhor padrão de corte do G2D, com α e ψ correntes;

� yR : melhor padrão de corte reativo;

� ZyR : valor de utilidade total do melhor padrão de corte reativo.

O pseudocódigo apresentado posteriormente é referente ao algoritmo proposto RG2D,

que obtém o padrão de corte yR de maior valor ZyR, a partir dos parâmetros reativos αR e ψR

em alguma das fases características da metodologia em destaque.

Algoritmo RG2D (Α,Ψ, iterC, iterR) 1. yR = 0, ZyR = 0, fαR = 0; 2. Para (α1 ∈ Α) faça 3. Para (ψ1 ∈ Ψ) faça 4. Execute G2D (α1, ψ1, maxiter, pitens, φ, δ), com maxiter = iterC; 5. Se (Zy

* > ZyR) então

6. αR = α1, ψR = ψ1, fαR = fαψ, yR = y*, ZyR = Zy*;

7. Se (Zy* = ZyR) então

74

8. Se (fαψ > fαR) então 9. αR = α1, ψR = ψ1, fαR = fαψ, yR = y*, ZyR = Zy

*; 10. Se (fαψ = fαR) então 11. Escolha, aleatoriamente, αR e atualize ψR, fαR, yR e ZyR; 12. Atualize Ψ = Ψ - {ψ1}; 13. Atualize A = A - {α1}; 14. Determine Α’; 15. Para (α2 ∈ Α’) faça 16. Execute G2D (α2, ψR, maxiter, pitens, φ, δ), com maxiter = iterR; 17. Se (Zy

* > ZyR) então

18. yR = y*, ZyR = Zy*;

19. Atualize A’ = A’ - {α2}; 20. Retorna (yR , ZyR);

Fim RG2D

4.5 RESULTADOS COMPUTACIONAIS

Para analisar o desempenho das versões reativas do algoritmo RG2D, foram

realizados testes em dois grupos de instâncias extensamente utilizadas na literatura,

totalizando 63 problemas, distinguidos pelos valores de utilidade dos itens e com a maioria

das soluções ótimas conhecidas. Esses resultados podem ser encontrados nos trabalhos de

Alvarez-Valdés et al. (2002a), Hifi (2004b), Chen (2008), Morabito e Pureza (2010) e

Dolatabadi et al. (2012).

As 24 instâncias do primeiro grupo, com valor de utilidade dos itens não

necessariamente atribuído a sua medida de área, são: ChW1, ChW2, ChW3, CW1-CW11 e

APT40-APT49. O segundo grupo com 39 instâncias, apresenta itens com valor de utilidade

relacionado à sua medida de área e é assinalado como: WANG1, WANG2, WANG3, OF1,

OF2, CU1-CU11, APT30-APT39 e gcut1-gcut13. Os problemas indicados com a sigla APT

são reconhecidos como de grande porte e seus dados podem ser obtidos na página de endereço

http://www.laria.u-picardie.fr/hifi/OR-Benchmark. As demais instâncias são disponibilizadas

pelo EURO Special Interest Group on Cutting and Packing (ESICUP) ou no repositório de

instâncias OR-Library, em seus respectivos endereços: http://paginas.fe.up.pt/~esicup/ e

http://people.brunel.ac.uk/~mastjjb/jeb/info.html.

Para variante sem rotação do PCBGR, os melhores resultados das consideradas

versões do RG2D são confrontados com os também produzidos pelos algoritmos propostos por

Alvarez-Valdés et al. (2002a), Morabito e Pureza (2010) e Dolatabadi et al. (2012). Os gaps

são calculados considerando as melhores soluções de toda a literatura. Alvarez-Valdés et al.

(2002a) apresentam, além de um sofisticado Busca Tabu, um algoritmo GRASP e a ampliação

desta GRASP com Path Relinking. Morabito e Pureza (2010) apresentam um algoritmo

heurístico que combina PD, busca em grafo E/OU e um procedimento para viabilização de

75

padrões de corte infactíveis. Já Dolatabadi et al. (2012) propõem um algoritmo recursivo

exato de busca exaustiva no espaço de soluções que necessita de limites inferiores e exteriores

externos. Estes algoritmos são indicados por TS50002, GRASP02, GR/PR02, DP_AOG10 e

A112, utilizando uma notação que destaca o ano de sua publicação. Vale ressaltar que não há

comparações do algoritmo heurístico proposto com outro algoritmo para o caso rotacionado

do PCBGR, porque não se conhece na literatura algum trabalho que abrangesse grande parte

dessas instâncias.

As versões dos algoritmos RG2D foram implementados em linguagem C/C++ (Visual

C++ 2010 Express) e seus testes foram realizados no ambiente computacional com núcleo

único de um processador Intel(R) Core(TM) i7-4790 3.6 GHz, com 16GB de memória RAM

e sistema operacional Windows 8.1 de 64 bits. Os algoritmos TS50002, GRASP02, GR/PR02

foram codificados em C++ e rodados em processador Pentium II 350 MHz. O DP_AOG10 foi

feito em Pascal (Delphi 7/Borland) e executado com processador Pentium IV 2.99 GHz e

2GB de RAM. Na execução do A112, utilizou-se também a linguagem C++ e seus testes

ocorreram no Intel(R) Dual CPU T3400 2.16 GHz. Segundo consulta ao benchmark

www.cpubenchmark.net, os processadores usados nos testes com os algoritmos DP_AOG e

A1 são, respectivamente, 3.5 e 3.1 vezes mais lentos do que o processador usado neste

trabalho.

Sabendo que os valores de função objetivo informam o valor de utilidade total do

padrão de corte, nas tabelas seguintes são apresentados os resultados médios e da melhor

solução obtida em 10 execuções com o respectivo algoritmo RG2D. Para conseguir os

referidos resultados, em todos os testes foram adotados os seguintes parâmetros: sorteios

estabelecidos a partir de semente aleatória; φ = 5 para a repetição de faixas homogêneas no

padrão de corte; δ = 10 para o reaproveitamento dos dentes nas faixas horizontais e verticais;

os conjuntos da fase de diversificação são estabelecidos como Α = {0.1, 0.2, 0.3, 0.4, 0.5} e

Ψ = {0.01, 0.02, 0.03, 0.04, 0.05}; o conjunto com os valores constituído a partir do αR na

fase reativa como Α’ = {αR, αR ± 0.025, αR ± 0.05}; como número máximo de iterações nas

respectivas fases iterC = 1000 para cada combinação de parâmetros α obtido em Α e ψ em Ψ e

iterR = 5000 para cada um dos valores pertencentes a A’, totalizando 50000 iterações; pitens =

50% na primeira metade das iterações e pitens = 10% nas seguintes para cada combinação de

α e ψ. É importante ressaltar que tal parametrização foi escolhida levando-se em consideração

que os tempos de execução médios não deveriam ultrapassar 60 segundos nas instâncias

utilizadas do PCBGR.

76

Para os casos sem rotação com peso e sem peso, os resultados dos algoritmos

referenciados encontram-se nas Tabelas 4.2-4.6. Nas Tabelas 4.2 e 4.3, as colunas 1-5 se

referem ao nome das instâncias clássicas, ao número de itens distintos, a totalidade desses

itens, o comprimento do objeto e sua largura, nessa ordem. Nas colunas 6-10 são apresentados

os respectivos resultados dos algoritmos GRASP, GR/PR, TS500 e DP_AOG, incluindo

apenas os tempos anotados para melhor solução e execução total desse último algoritmo. Em

seguida, nas colunas 11-13, têm-se o resultado médio em 10 rodadas, da melhor solução

gerada nessas execuções e, assim como o DP_AOG, os tempos relacionados à melhor solução

do RG2D. As três colunas finais 14-16 informam os parâmetros α e ψ da melhor solução

encontrada com o RG2D e o seu respectivo gap percentual da melhor solução. As Tabelas 4.4-

4.5 mostram os resultados das instâncias abreviadas de APT e diferem das tabelas anteriores

por apresentar nas colunas 9 e 10 informações relacionadas às soluções do algoritmo A1 e seu

tempo de execução. Já na Tabela 4.6, as colunas 1-5 mostram os dados das instâncias gcut,

que possuem itens com demanda unitária e os resultados dos algoritmos A1 e RG2D nas

demais colunas.

É necessário observar ainda nessas tabelas, que os tempos expostos estão em

segundos, as colunas com os tempos referentes aos algoritmos DP_AOG e RG2D mostram o

tempo para encontrar a melhor solução e o tempo de execução total, nessa ordem. Como o

algoritmo A1 sempre converge para a melhor solução, é apresentado apenas seu tempo de

execução. Entretanto, destaca-se que o algoritmo A1 utiliza limites procedentes de algoritmos

externos e os tempos para obtenção desses valores são desconsiderados. Em Alvarez-Valdés

et al. (2002a), não especificaram os tempos individuais nos testes dos algoritmos propostos

em seu trabalho, apenas relataram os tempos médios que consideram também a resolução de

outras instâncias do PCBGR. Além disso, as tabelas dessa seção adotam uma simbologia

distinguida da seguinte forma: as instâncias não executadas por alguns desses algoritmos são

indicadas com -; se o valor da melhor solução gerada com o RG2D for superior às

apresentadas pelos algoritmos GRASP, GR/PR e TS500, esta é assinalada com o sobrescrito

dos respectivos números 1, 2 e 3; no caso de gap negativo para melhor solução do RG2D, esta

é apresentada em negrito; as soluções ótimas conhecidas na literatura são denotadas com * e

os ótimos obtidos com certificação possuem **.

Os resultados da Tabela 4.2, constituído de 14 instâncias sem rotação e com peso do

PCBGR, mostram que o RG2Dv conseguiu 11 soluções ótimas. Os tempos computacionais de

execução do algoritmo DP_AOG são confrontáveis, pois a máquina utilizada nos testes do

RG2Dv é 3.5 vezes mais rápida. Mesmo com a impossibilidade de comparar tempos com os

77

algoritmos em Alvarez-Valdés et al. (2002a), os ótimos adicionais obtidos nas instâncias

CW2, CW4, CW5 e CW7 indicam superioridade do algoritmo RG2Dv quando comparado às

soluções apresentadas pelos GRASP e GR/PR. O RG2Dv apresentou resultados comparáveis

aos do TS500 e inferiores ao DP_AOG em 3 instâncias. Nas instâncias com gap indesejável,

pressupõe-se que as estratégias adotadas na construção das faixas, que consideram as

dimensões das faixas definidas por um único item e a utilização dos itens em sua composição

na maior quantidade disponível sem inviabiliza-la, podem impedir a geração desses padrões

de corte.

Analisando os resultados mostrados na Tabela 4.3, verifica-se que nas 16 instâncias

sem peso, o algoritmo RG2Da encontrou 12 soluções ótimas e as demais apresentaram gap

inferior a 0,0026, indicando que essa abordagem reativa é melhor quando aplicada ao caso

sem peso. Em tais instâncias, a superioridade nas comparações com os algoritmos GRASP,

GR/PR e TS500 pode ser verificada pela qualidade das soluções produzidas em CU4, CU8 e

CU11. Já na comparação com o DP_AOG, destacam-se os tempos médios para obter a melhor

solução e de execução do RG2Da com 3.5 e 14.0 segundos contra 25.8 e 368.9 segundos.

Ao confrontar os resultados apresentados por Velasco e Uchoa (2014b) nessas 30

instâncias clássicas com os algoritmos G2Dv e G2Da com os das Tabelas 4.2 e 4.3, verifica-se

que as respectivas versões reativas com suas ampliações RG2Dv e RG2Da melhoraram esses

resultados, reduzindo o gap nas 7 instâncias indicadas por CW4*, CW6, CW8*, CW10,

CU4*, CU8* e CU11 e acrescentando as 4 novas soluções ótimas destacadas com *.

A Tabela 4.4 expõe os resultados das instâncias APT40-APT49, para o caso sem

rotação e com peso. O algoritmo exato A1 destaca-se pelo quantitativo de soluções ótimas e a

heurística TS500 pela qualidade de suas soluções, superando o algoritmo proposto RG2Dv em

7 dessas instâncias, empatando em 2 e perdendo na APT48. Na comparação entre as

heurísticas baseadas na GRASP, o RG2Dv é bem superior aos algoritmos GRASP e GR/PR,

perdendo apenas nas instâncias APT44 e APT47. É importante destacar que os tempos

computacionais apresentados pelo RG2Dv com a parametrização adotada reiteram sua relativa

eficiência diante dos resultados apresentados pelo algoritmo A1. Esta observação se deve ao

fato que os limites inferior e superior utilizados como dados de entrada no algoritmo A1foram

fornecidos por Hifi (2004b) e Chen (2008) sem que os respectivos tempos tenham sido

computados. Em particular, as soluções de valor 33503 e 214561 para as instâncias APT42 e

APT43 vieram diretamente de Hifi (2004b), o algoritmo A1 não conseguiu melhorar essas

soluções e nem provar sua otimalidade no tempo limite de 3600 segundos.

78

TABELA 4.2 – Resultados nas Instâncias Clássicas sem Rotação e com Peso.

Instâncias AlgoritmosNome m m̅ C L GRASP02 GR/PR02 TS50002 DP_AOG10 Tempo RG2DMed RG2 D Tempo Alfa Psi Gap(%)

ChW1 7 16 15 10 - - - **244 <0.1 0.1 *244.0 *244 <0.1 4.3 0.5 0.05 0ChW2 10 23 40 70 *2892 *2892 *2892 **2892 0.8 38.4 2842.6 *2892 0.6 5.5 0.2 0.05 0ChW3 20 62 40 70 *1860 *1860 *1860 **1860 0.1 19.9 *1860.0 *1860 <0.1 11.8 0.1 0.05 0CW1 25 67 125 105 *6402 *6402 *6402 **6402 1.1 25.6 *6402.0 *6402 <0.1 11.9 0.2 0.05 0CW2 35 63 145 165 5333 5333 *5354 *5354 0.7 1118.8 5339.4 ¹²*5354 0.1 11.3 0.1 0.05 0CW3 40 96 267 207 *5689 *5689 *5689 **5689 0.5 26.9 5675.2 *5689 14.1 17.1 0.225 0.01 0CW4 39 86 465 387 6158 6165 6170 **6175 1.3 46.8 6161.4 ¹²³*6175 9.4 16.3 0.05 0.02 0CW5 35 91 524 678 11580 11580 11644 **11659 0.8 1268.5 11594.3 ¹²³*11659 7.7 14.9 0.15 0.02 0CW6 55 149 781 657 12907 *12923 *12923 **12923 33.3 890.6 12221.3 12651 1.1 28.2 0.1 0.04 2.10CW7 45 123 276 374 9687 9687 *9898 **9898 4.1 10.7 9783.1 ¹²*9898 2.0 21.3 0.1 0.01 0CW8 60 168 305 287 *4605 *4605 *4605 **4605 20.8 340.5 4434.8 *4605 <0.1 34.4 0.1 0.05 0CW9 50 131 405 362 *10748 *10748 *10748 **10748 7.0 121.3 10723.3 *10748 0.3 25.4 0.1 0.05 0CW10 60 130 992 970 6016 *6515 *6515 **6515 2.8 182.2 6149.4 ¹6471 23.6 29.7 0.125 0.04 0.68CW11 60 114 982 967 *6321 *6321 *6321 **6321 2.0 1375.0 6006.3 6084 11.8 24.8 0.15 0.03 3.75Média 5.4 390.4 5.1 18.3

78

79

TABELA 4.3 – Resultados nas Instâncias Clássicas sem Rotação e sem Peso.

Instâncias AlgoritmosNome m m̅ C L GRASP02 GR/PR02 TS50002 DP_AOG10 Tempo RG2DM ed RG2 D Tempo Alfa Psi Gap(%)

WANG1 20 42 33 69 - - - **2277 <0.1 0.1 *2277.0 *2277 <0.1 7.1 0.5 0.05 0WANG2 20 42 39 70 - - - **2694 <0.1 0.2 *2694.0 *2694 <0.1 6.7 0.1 0.05 0WANG3 20 42 40 70 *2721 *2721 *2721 **2721 <0.1 0.6 *2721.0 *2721 <0.1 7.0 0.4 0.05 0OF1 10 23 70 40 *2737 *2737 *2737 **2737 0.1 11.2 *2737.0 *2737 0.3 5.5 0.5 0.05 0OF2 10 24 70 40 *2690 *2690 *2690 *2690 0.1 23.6 *2690.0 *2690 <0.1 4.2 0.2 0.04 0CU1 25 82 100 125 12312 12312 *12330 **12330 0.1 0.5 *12330.0 ¹²*12330 <0.1 11.5 0.5 0.05 0CU2 35 90 150 175 *26100 *26100 *26100 **26100 0.2 1.4 *26100.0 *26100 0.1 14.7 0.1 0.05 0CU3 45 158 134 125 16652 16652 16679 **16723 0.3 5.8 16638.3 ¹²16679 17.4 24.8 0.1 0.02 0.26CU4 45 113 285 354 99264 99264 99366 **99495 3.8 35.0 99292.8 ¹²³*99495 10.0 17.2 0.15 0.05 0CU5 50 120 456 385 *173364 *173364 *173364 **173364 2.7 873.2 173003.0 173010 0.1 22.2 0.1 0.05 0.20CU6 45 124 356 447 *158572 *158572 *158572 **158572 1.3 11.8 *158572.0 *158572 <0.1 19.3 0.1 0.05 0CU7 25 56 563 458 *247150 *247150 *247150 *247150 0.1 1800.0 247049.0 *247150 0.1 9.3 0.1 0.05 0CU8 35 78 587 756 432714 432714 432714 **433331 0.5 26.8 432617.0 ¹²³*433331 9.1 14.0 0.075 0.04 0CU9 25 76 856 785 651597 *657055 *657055 **657055 0.1 19.7 *657055.0 ¹*657055 <0.1 13.2 0.5 0.05 0CU10 40 129 794 985 767580 770659 773485 *773772 69.2 1800.0 772445.0 ¹²772982 3.5 21.7 0.2 0.02 0.10CU11 50 134 977 953 909898 914399 922161 *924696 333.6 1293.1 918369.0 ¹²³924311 14.6 24.7 0.15 0.01 0.04Média 25.8 368.9 3.5 14.0

79

80

TABELA 4.4 – Resultados nas Instâncias APT sem Rotação e com Peso.

TABELA 4.5 – Resultados nas Instâncias APT sem Rotação e sem Peso.

Instâncias AlgoritmosNome m m̅ C L GRASP02 GR/PR02 TS50002 A112 Tempo RG2DMed RG2D Tempo Alfa Psi Gap(%)

APT40 56 290 138 683 65002 65002 66362 **67154 25.86 64713.5 ¹²65896 13.19 50.20 0.3 0.01 1.87APT41 36 177 367 837 199349 200826 *206542 **206542 229.30 202839.1 ¹²206302 1.19 27.89 0.1 0.03 0.12APT42 59 325 291 167 32644 32714 33435 33503 3600.00 32048.1 ¹²32770 3.39 52.47 0.1 0.02 2.19APT43 49 259 917 362 206627 206627 214651 214651 3600.00 212302.9 ¹²214471 16.92 41.27 0.5 0.05 0.08APT44 39 196 496 223 72261 72906 73410 **73868 19.23 72048.8 ¹72895 0.73 25.67 0.1 0.04 1.32APT45 33 156 578 188 73210 73231 *74691 **74691 19.73 72773.3 ¹²*74691 0.64 22.95 0.1 0.04 0APT46 42 197 514 416 147340 147387 *149911 **149911 37.00 147945.9 ¹²*149911 8.38 31.09 0.3 0.01 0APT47 43 204 554 393 148638 148638 148764 **150234 51.80 144126.5 146892 29.20 33.16 0.425 0.03 2.22APT48 34 167 254 931 163484 166115 166927 **167660 75.93 163146.4 ¹²³167023 20.02 23.34 0.125 0.03 0.38APT49 25 119 449 759 209472 211570 215728 **219354 2680.39 211099.3 ¹²214365 6.39 18.19 0.4 0.02 2.27

Média 1033.92 10.00 32.62

Instâncias AlgoritmosNome m m̅ C L GRASP02 GR/PR02 TS50002 A112 Tempo RG2DMed RG2D Tempo Alfa Psi Gap(%)

APT30 38 192 152 927 138863 138863 140144 **140904 2.43 139930.6 ¹²³140461 7.62 30.64 0.3 0.02 0.31APT31 51 258 964 856 801767 804476 814081 **823976 178.99 819712.6 ¹²³821345 10.93 43.06 0.3 0.02 0.32APT32 56 249 124 307 37786 37810 38030 **38068 0.37 37974.6 ¹²38011 29.89 41.16 0.5 0.01 0.15APT33 44 224 983 241 231178 231367 234920 **236611 40.62 235302.8 ¹²³236024 3.36 33.22 0.2 0.05 0.25APT34 27 130 456 795 353822 353822 360084 **361398 79.08 359543.0 ¹²³360420 19.00 21.46 0.225 0.01 0.27APT35 29 153 649 960 607864 612997 620700 **621021 15.36 617964.4 ¹²619426 1.17 20.36 0.1 0.03 0.26APT36 28 153 244 537 129634 130156 130338 **130744 18.06 129826.2 ¹²130276 21.43 24.91 0.425 0.02 0.36APT37 43 222 881 440 379329 379329 381966 **387276 48.03 384875.9 ¹²³385828 1.82 30.11 0.1 0.02 0.37APT38 40 202 358 731 252605 252886 259380 **261395 44.63 259742.3 ¹²³260622 2.77 29.95 0.1 0.01 0.30APT39 33 163 501 538 263076 263471 267168 **268750 33.70 267972.9 ¹²³268081 4.69 25.02 0.2 0.01 0.25

Média 46.13 10.27 29.99

80

81

Já na Tabela 4.5, podem ser comparados os resultados dos algoritmos supracitados

nas instâncias sem peso APT30-APT39. Superando os algoritmos GRASP e GR/PR em todas

as instâncias e fazendo 7 soluções melhores do que o TS500, seus resultados acentuam sua

predominância nessa variante do PCBGR. Ainda que o algoritmo RG2Da não tenha gerado

alguma solução ótima nas instâncias APT30-39, os tempos computacionais apresentados pelo

RG2Da estão condizentes com a proposta de uma heurística. Visto que nos tempos computados

do A1 não são considerados a determinação dos seus limites essenciais

Os resultados dos algoritmos A1 e RG2Da nas instâncias gcut podem ser discutidos a

partir da Tabela 4.6. O algoritmo RG2Da mostra excelente desempenho em instâncias sem peso

e com demanda unitária para cada item. Não somente a quantidade de soluções ótimas

observada, inclusive em suas médias, e seus tempos computacionais corrobora essa afirmativa

em tal comparação com o algoritmo A1, mas também o gap negativo da solução gerada por

RG2Da para gcut13 de valor 8618394.

TABELA 4.6 – Resultados nas Instâncias gcut sem Rotação e sem Peso.

Os resultados dos algoritmos propostos RG2Dvr e RG2Dar, para o PCBGR com rotação

nas variantes com peso e sem peso, com a mesma configuração de parâmetros nesses grupos

de instâncias, estão disponibilizados nas Tabelas 4.7-4.9. Como não se encontra um trabalho

de grande relevância na literatura do PCBGR rotacionado, os novos resultados ainda não são

confrontados com outro algoritmo. Entretanto, no Capítulo 5 será apresentado o algoritmo

X2D para o PCBGR que também contempla o caso com rotação. Nas colunas que apresentam

os percentuais de gap das referidas tabelas, estes são calculados a partir dos limites superiores

Instâncias AlgoritmosNome m m̅ C L A112 Tempo RG2DMe d RG2D Tempo Alfa Psi Gap(%)

gcut1 10 10 250 250 **48368 2.89 *48368.0 *48368 <0.01 2.23 0.3 0.05 0gcut2 20 20 250 250 **59307 5.56 *59307.0 *59307 <0.01 4.36 0.4 0.05 0gcut3 30 30 250 250 **60241 6.50 *60241.0 *60241 0.28 6.33 0.4 0.04 0gcut4 50 50 250 250 **60942 12.95 *60942.0 *60942 <0.01 11.91 0.5 0.05 0gcut5 10 10 250 250 **195582 4.35 193379.0 193379 <0.01 2.26 0.1 0.05 1.13gcut6 20 20 500 500 **236305 7.13 *236305.0 *236305 <0.01 4.30 0.5 0.05 0gcut7 30 30 500 500 **238974 11.06 *238974.0 *238974 <0.01 6.44 0.4 0.05 0gcut8 50 50 500 500 **245758 18.71 *245758.0 *245758 <0.01 11.28 0.5 0.05 0gcut9 10 10 500 500 **919476 14.51 *919476.0 *919476 <0.01 2.81 0.4 0.05 0gcut10 20 20 1000 1000 **903435 17.85 *903435.0 *903435 <0.01 3.88 0.5 0.05 0gcut11 30 30 1000 1000 **955389 29.65 *955389.0 955389 0.03 6.44 0.5 0.05 0gcut12 50 50 1000 1000 **970744 46.48 *970744.0 970744 <0.01 11.44 0.4 0.05 0gcut13 32 32 3000 3000 8532720 3600.00 8550366.5 8618394 2.00 13.23 0.2 0.03 -1.00

Média 290.59 0.18 6.69

82

produzidos pelo X2D.

Para simplificar, as novas tabelas não possuem os dados completos das respectivas

instâncias. Basicamente, as Tabelas 4.7 e 4.8 reúnem as instâncias da literatura antes

observadas nas Tabelas 4.2 e 4.3, nas Tabelas 4.9 e 4.10 concentram-se as instâncias APT

referentes às Tabelas 4.4 e 4.5 e as instâncias gcut encontram-se na Tabela 4.11.

TABELA 4.7 – Resultados nas Instâncias Clássicas com Rotação e com Peso.

TABELA 4.8 – Resultados nas Instâncias Clássicas com Rotação e sem Peso.

Instâncias AlgoritmoNome m RG2DMed RG2D Tempo Alfa Psi Gap(%)

ChW1 7 *260.0 *260 <0.1 4.6 0.4 0.05 0ChW2 10 2867.1 2896 0.8 6.4 0.2 0.04 0.17ChW3 20 1902.0 *1920 0.4 12.8 0.1 0.04 0CW1 25 6747.8 6764 0.8 11.6 0.1 0.02 0.30CW2 35 5461.3 *5689 6.4 12.8 0.15 0.01 0CW3 40 5656.6 *5744 0.8 17.9 0.1 0.03 0CW4 39 7432.0 7466 10.2 17.8 0.15 0.01 0.40CW5 35 11587.9 *11659 16.5 16.9 0.15 0.01 0CW6 55 12086.1 12967 21.6 30.0 0.1 0.02 1.79CW7 45 10656.7 *10880 0.3 21.9 0.1 0.05 0CW8 60 4571.5 *4736 8.6 37.1 0.3 0.04 0CW9 50 10737.4 *11479 18.9 27.5 0.075 0.05 0CW10 60 6343.7 *6835 21.2 31.3 0.075 0.04 0CW11 60 6299.5 6520 20.1 25.5 0.1 0.03 3.89Média 9.1 19.6

Instâncias AlgoritmoNome m RG2DMed RG2 D Tempo Alfa Psi Gap(%)

WANG1 20 *2277.0 *2277 <0.1 7.6 0.5 0.05 0WANG2 20 *2716.0 *2716 <0.1 8.4 0.5 0.05 0WANG3 20 *2771.0 *2771 0.1 8.4 0.4 0.05 0OF1 10 2735.8 2737 1.4 4.9 0.3 0.01 0.73OF2 10 *2769.0 *2769 <0.1 4.9 0.3 0.04 0CU1 25 *12500.0 *12500 <0.1 12.8 0.1 0.05 0CU2 35 *26200.0 *26200 0.2 15.7 0.1 0.05 0CU3 45 16695.5 16723 4.8 26.4 0.2 0.02 0.16CU4 45 99868.0 100158 2.2 18.4 0.2 0.05 0.07CU5 50 *174705.0 *174705 <0.1 25.8 0.1 0.05 0CU6 45 158520.0 *158572 0.3 20.8 0.1 0.05 0CU7 25 254183.0 *255684 6.2 9.3 0.075 0.05 0CU8 35 437652.0 *438383 0.9 15.2 0.1 0.03 0CU9 25 658330.0 *659648 5.5 15.7 0.4 0.04 0CU10 40 774990.0 777112 22.1 24.4 0.25 0.04 0.27CU11 50 922813.0 927133 4.6 28.3 0.2 0.02 0.12Média 3.0 15.4

83

Na Tabela 4.7 das instâncias denominadas clássicas com peso, constatam-se 9

soluções ótimas, 3 soluções apresentando gap menor do que 0.01 e outras 2 com gap superior

a este valor. Com o total de 20 soluções ótimas, incluindo as soluções mostradas na Tabela

4.8 para as instâncias sem peso, produzidas em tempos relativamente pequenos, deduz-se que

as propostas reativas RG2Dvr e RG2Dar também podem ser aplicadas com sucesso em instâncias

consideradas pequenas e médias do PCBGR rotacionado.

Os resultados das instâncias de grande porte indicadas pela sigla ATP e do caso com

rotação encontram-se nas Tabelas 4.9 e 4.10. De acordo com o tamanho das instâncias e

analisando o gap percentual apresentado nas respectivas tabelas supracitadas, verifica-se que

a versão reativa do RG2D para tratar o caso com rotação e sem peso também é mais eficiente

do que para o mesmo tratar a variante com peso.

TABELA 4.9 – Resultados nas Instâncias APT com Rotação e com Peso.

TABELA 4.10 – Resultados nas Instâncias APT com Rotação e sem Peso.

Instâncias AlgoritmoNome m RG2DMed RG2D Tempo Alfa Psi Gap(%)

APT40 56 65163.1 65961 8.69 47.19 0.2 0.01 1.98APT41 36 208163.9 210075 9.94 27.08 0.4 0.02 0.73APT42 59 32549.8 33073 35.13 59.38 0.05 0.03 2.76APT43 49 213911.3 214092 6.92 39.19 0.2 0.01 2.53APT44 39 73883.6 75127 14.16 27.67 0.25 0.01 1.55APT45 33 73484.3 *74691 1.01 23.36 0.1 0.03 0APT46 42 148441.3 150680 24.73 37.83 0.375 0.05 0.20APT47 43 146606.6 149866 29.59 34.69 0.425 0.03 2.02APT48 34 167861.8 170039 0.81 23.66 0.1 0.04 1.08APT49 25 213932.5 219264 19.42 19.70 0.25 0.01 2.54

Média 15.04 33.97

Instâncias AlgoritmoNome m RG2DM ed RG2D Tempo Alfa Psi Gap(%)

APT30 38 139939.3 140461 8.19 33.64 0.3 0.03 0.31APT31 51 822141.9 823978 22.59 46.58 0.5 0.01 0.15APT32 56 38050.9 *38068 27.06 38.47 0.5 0.01 0APT33 44 235689.5 236135 8.72 34.02 0.3 0.02 0.32APT34 27 360794.0 361292 1.53 20.69 0.1 0.02 0.34APT35 29 619251.8 619871 6.97 24.98 0.3 0.01 0.50APT36 28 130102.3 130628 0.08 21.69 0.1 0.05 0.27APT37 43 385664.9 387097 11.75 32.19 0.4 0.02 0.14APT38 40 260459.5 260943 2.16 32.38 0.1 0.02 0.29APT39 33 268336.2 269181 13.88 30.20 0.5 0.01 0.07

Média 10.29 31.48

84

Na Tabela 4.11 estão descritos os resultados do algoritmo RG2Dar nas instâncias gcut

para a variante do PCBGR sem peso e com rotação. Ainda que no cálculo desses gaps sejam

utilizados os respectivos limites superiores do algoritmo X2D, que serão esclarecidos no

próximo capítulo, é importante ressaltar que a solução gerada para instância gcut13 de valor

8825746 é domínio exclusivo do algoritmo RG2Dar.

TABELA 4.11 – Resultados nas Instâncias gcut com Rotação e sem Peso.

Na Figura 4.14, padrões de corte obtidos com a execução dos algoritmos RG2Da e

RG2Dar são ilustrados. Destacam-se então, as soluções da instância APT33, tanto para o

PCBGR sem rotação (a) como para a variante rotacionada (b). Seus valores totais são 236024

e 236135, respectivamente, e as representações na forma de strings de caracteres são descritas

como V2P26A1P40A1P37a1P37 H4P39 V2P36 V2P36 V2P36 V2P30A1P10 e H3P17

V1P39A1P15 H3P18 V4R10M1R4m1R4 H1P29.

Instâncias AlgoritmoNome m RG2DM ed RG2D Tempo Alfa Psi Gap(%)

gcut1 10 *58136.0 *58136 <0.01 2.82 0.5 0.05 0gcut2 20 *60403.0 *60403 0.02 5.22 0.4 0.04 0gcut3 30 60485.0 60485 0.05 7.43 0.3 0.05 0.20gcut4 50 *61710.0 *61710 0.01 13.60 0.5 0.05 0gcut5 10 *233969.0 *233969 <0.01 2.78 0.4 0.05 0gcut6 20 *239393.0 *239393 <0.01 4.80 0.1 0.05 0gcut7 30 *245306.0 *245306 0.02 7.55 0.3 0.04 0gcut8 50 *247462.0 *247462 0.01 12.63 0.3 0.04 0gcut9 10 *933169.0 *933169 <0.01 3.10 0.5 0.05 0gcut10 20 922695.0 922695 0.01 4.62 0.3 0.05 0.88gcut11 30 *969151.0 *969151 0.01 7.72 0.5 0.05 0gcut12 50 979728.6 980640 0.46 12.60 0.1 0.04 0.10gcut13 32 8739934.3 8825746 3.08 15.83 0.2 0.01 1.91

Média 0.28 7.75

85

Padrões de Corte APT33 com RG2D

P26

P26

P

40

P37

P37

P39P39 P39 P39

P36

P36

P36

P36

P36

P36

P30

P30

P10

(a) (b)

FIGURA 4.14 – Padrões de Corte APT33 com Algoritmo RG2D.

86

5 ALGORITMO PRIMAL-DUAL PARA O PCBGR

O presente capítulo descreve uma conjunção de métodos denominada X2D e

resultante de técnicas baseadas em Programação Dinâmica (PD), Programação Inteira (PI) e

na metaheurística GRASP, para tratar as variantes do PCBGR abordadas anteriormente em

relação ao valor e a rotação dos itens. Além do algoritmo primal RG2D já apresentado no

Capítulo 4, são propostos os algoritmos duais X e X2, a heurística primal X2H e a

organização desses quatro elementos que resulta no algoritmo primal-dual X2D. A importância

dessa nova abordagem primal-dual pode ser compreendida na sua capacidade de obter

soluções com garantia de qualidade ou mesmo certificado de otimalidade para o problema em

destaque.

Basicamente, o algoritmo X baseia-se em PI e é capaz de provadamente obter os

pesos ótimos para a relaxação de espaço de estados da PD proposta por Christofides e

Hadjiconstantinou (1995). O algoritmo X2 é proposto como uma generalização de X, que usa

pesos bidimensionais para obter limites ainda mais fortes. Já o algoritmo X2H, consiste na

adaptação de X2 para transformá-lo em uma heurística primal. Uma composição dos

algoritmos X, X2, RG2D e X2H constitui o algoritmo X2D que é executado em quatro fases

interligadas e nessa ordem, atualizando o melhor limite superior (ZUB) somente nas duas

primeiras fases pela solução ótima da PD relaxada de X ou X2 e o melhor limite inferior (ZLB)

oriundo das soluções viáveis geradas nas respectivas quatro fases. No decorrer desse

processo, se a solução corrente ocasionar a igualdade ZUB = ZLB, então a esta solução é

assegurado o certificado de otimalidade e isto encerraria a execução.

Sendo a PD uma metodologia reconhecida na literatura dos Problemas de Corte e

Empacotamento, esta é tida como primordial na geração de padrões de corte tanto para o

PCBGI quanto para o PCBGR com a relaxação de espaço de estados. Em consequência, é

descrito com destaque a utilização da referida técnica nas subseções seguintes para ambos os

problemas.

5.1 PROGRAMAÇÃO DINÂMICA PARA O PCBGI

Um padrão de corte ótimo para o PCBGI pode ser gerado a partir das soluções dos

subproblemas dados pela aplicação de cada um dos possíveis cortes guilhotinados horizontais

ou verticais. Isso permite que este problema seja resolvido via PD em tempo pseudo-

polinomial e a complexidade do algoritmo depende dos valores de C e L. Diferentemente da

abordagem proposta por Gilmore e Gomory (1965), as fórmulas de recorrência apresentadas

87

por Beasley (1985) não limitam a quantidade de estágios no padrão de corte e juntamente com

os conceitos de Pontos de Discretização de Herz (1972), são utilizadas por Cintra et al. (2008)

no desenvolvimento de um algoritmo exato para o PCBGI como segue.

5.1.1 PROGRAMAÇÃO DINÂMICA PARA DISCRETIZAÇÃO

Para determinar os pontos de discretização em um objeto R = (C, L), a partir das

dimensões dos itens requisitados, utiliza-se uma técnica de PD para o problema da mochila

que providencia o preenchimento ótimo de uma mochila de capacidade inteira D, por itens de

peso e valor igual a di, com i = 1,...,m. Define-se que os pontos de discretização do

comprimento C calculados como uma combinação cônica inteira dos comprimentos dos itens

nessa dimensão pertencem ao conjunto P. De forma análoga, tem-se em Q os pontos

associados à largura L. O pseudocódigo do algoritmo Discretization using Dynamic

Programming (DDP), que retorna o conjunto P dos pontos de discretização para uma

dimensão D, é apresentado a seguir.

Algoritmo DDP (D, d) 1. P ={0}; 2. Para (j = 0,..., D) faça cj = 0; 3. Para (i = 1,..., m) faça 4. Para (j = di,..., D) faça 5. Se (cj < cj - di + di) então cj = cj - di + di; 6. Para (j = 1,..., D) faça 7. Se (cj = j) então P = P ∪ {j}; 8. Retorna (P);

Fim DDP

Sejam cmin e lmin o menor comprimento e a menor largura entre os itens nessa ordem.

Denomina-se por P0 o conjunto dos pontos de discretização associados ao comprimento C do

objeto com o elemento genérico p ≤ C - cmin. Analogamente, define-se Q0 como conjunto dos

pontos de discretização associados à largura L e elemento genérico q ≤ L - lmin. Com as

devidas inserções no algoritmo DDP, a substituição dos respectivos conjuntos P e Q pelos

conjuntos P1 = P0 ∪ {C} e P2 = Q0 ∪ {L} vão produzir significativo ganho computacional na

execução do algoritmo descrito na próxima subseção.

Estabelecendo que os cortes guilhotinados horizontal e vertical em R são realizados

apenas nestes pontos de discretização, o padrão de corte ótimo para o PCBGI é categorizado

de canônico por Herz (1972).

5.1.2 ALGORITMO DYNAMIC PROGRAMMING

O algoritmo Dynamic Programming (DP) aproveita os pontos de discretização com o

88

intuito de obter exclusivamente padrões canônicos. Isto significa que o padrão de corte ótimo

para o PCBGI que o DP retorna, apresenta suas faixas guilhotinas geradas a partir de cortes

realizados apenas nestes pontos discretizados.

Considerando que v(c, l) = max({vi|1 ≤ i ≤ m, ci ≤ c, li ≤ l} ∪ {0}) é o maior valor

obtido com a produção de um único item no subretângulo (c, l) ou 0 caso não caiba algum

item. Admitindo a possibilidade de um padrão de corte não possuir cortes guilhotina ou

apresentar o primeiro corte guilhotina vertical na posição c’ ou mostrar o primeiro corte

guilhotina horizontal na posição l’, a seguinte fórmula de recorrência é utilizada

construtivamente conforme descrito na sequência.

Inicialmente, para cada subretângulo de dimensões pi ∈ P1 e qj ∈ P2, o item de maior

valor é designado. Na sequência, ainda para os subretângulos (pi, qj), verifica-se para cada

possível corte vertical em px ou horizontal em qy, com px ≤ pi/2 e qy ≤ qj/2 arredondados para

baixo, se este promove alteração no valor ótimo de (pi, qj) considerando a melhor utilização

dos subretângulos (pi-px, qj) ou (pi, qj-qy), nessa ordem, com i = 1,..,r e j = 1,..,s. Sendo assim,

na composição da solução ótima, o processo inicia-se com o menor subretângulo (pi, qj) e

conforme as dimensões desses subretângulos vão aumentando, até atingir as dimensões de R,

as informações sobre as suas respectivas melhores soluções parciais e seus valores são

utilizadas na determinação do padrão ótimo de corte.

Uma descrição do algoritmo DP (CINTRA et al., 2008), que utiliza as informações

da instância como dados de entrada e retorna o padrão de corte ótimo (PCIOtimo) para o

PCBGI com peso atribuído aos itens, é apresentada como segue.

Algoritmo DP (C, L, c, l, v) 1. Determine pi < ... < pr, os pontos de discretização do conjunto P1; 2. Determine qi < ... < qs, os pontos de discretização do conjunto P2; 3. Para (i = 1,..., r) faça 4. Para (j = 1,..., s) faça 5. V(i, j) = max ({vk|1 ≤ k ≤ m, ck ≤ pi e lk ≤ qj}∪{0}); 6. item(i, j) = max ({k|1 ≤ k ≤ m, ck ≤ pi, lk ≤ qj e vk = V(i, j)}∪{0}); 7. guilhotina(i, j) = nil; 8. Para (i = 2,..., r) faça 9. Para (j = 2,..., s) faça n = max(k|1 ≤ k ≤ i e pk ≤ [[pi/2]]); 10. Para (x = 1,..., n) faça t = max(k|1 ≤ k ≤ r e pk ≤ pi - px); 11. Se (V(i, j) < V(x, j) + V(t, j)) então 12. V(i, j) = V(x, j) + V(t, j), posição(i, j) = px e guilhotina(i, j) = ‘V’; 13. n = max(k|1 ≤ k ≤ j e qk ≤ [[qj/2]]);

( )

( )

( ) ( )

( ) ( )1

2

{v c, l

V c, l {V c’, l + V c - c’, l c’ P , ’

}

= max | c } c/2

V c, l’ + V c, l - l’ l’ P , l’

{ | } l/ 2

∈ ≤

∈ ≤

U

U

(5.1)

89

14. Para (y = 1,..., n) faça t = max(k|1 ≤ k ≤ s e qk ≤ qj - qy); 15. Se (V(i, j) < V(i, y) + V(i, t)) então 16. V(i, j) = V(i, y) + V(i, t), posição(i, j) = qy e guilhotina(i, j) = ‘H’; 17. Retorna (PCIOtimo);

Fim DP

Na reconstrução do padrão de corte ótimo, o algoritmo DP recupera em determinada

matriz as informações referentes à direção e posição do primeiro corte guilhotina, realizado

nos subretângulos determinados a partir dos pontos de discretização. Se não houver

ocorrência de corte guilhotina, é indicado qual item deve ser produzido nesse subretângulo.

Isto é, os subretângulos de dimensões (pi, qj) apresentam valor de utilidade ótimo V(i, j) ≤

V(r, s), guilhotina(i, j) indica a direção horizontal ou vertical do primeiro corte e item(i, j)

aponta onde deve ser feito este primeiro corte. Se guilhotina(i, j) = nil, então nenhum corte

guilhotina é realizado e item(i, j) determina qual item deve ser gerado em (pi, qj).

O algoritmo descrito anteriormente também pode gerar padrões ótimos para PCBGI

com peso e rotação. Neste caso, para cada item de uma instância com dimensões ci ≠ li , ci ≤

C, li ≤ L e valor de utilidade vi, foi adicionado a essa instância um novo item (li, ci),

apresentando o mesmo valor de utilidade vi, com i = 1,...,m.

5.2 PROGRAMAÇÃO DINÂMICA PARA O PCBGR

A resolução do PCBGR por PD pode ser muito mais desafiadora do que a do PCBGI.

Isso se deve a necessidade de controlar quantas cópias de cada item vão estar nas soluções de

cada um dos subproblemas. Sejam d = [d1,..., dm] e δ = [δ1,..., δm] vetores de m dimensões

indicando a demanda original dos itens e o maior número permitido de cópias de cada item na

solução de um subproblema, respectivamente. Define-se v(c, l, δ) = max({vi | 1 ≤ i ≤ m, ci ≤ c,

li ≤ l, δi ≥ 1} ∪ {0}) como o maior valor obtido com a possível produção de um único item i

sem rotação e com δi positivo no subretângulo (c, l). Considerando que o padrão de corte

ótimo pode ser composto por um único item ou ter um corte guilhotinado vertical na posição

c’ ou possuir um corte guilhotinado horizontal na posição l’, o valor da melhor solução no

subretângulo (c, l) respeitando as respectivas demandas máximas indicadas em δ é obtido pela

seguinte recorrência:

onde P1 e são P2 os pontos de discretização para os cortes verticais e horizontais.

( )

( )

( ) ( )

( ) ( )1

2

{v c, l,

V c, l, {V c’, l, ’ + V c - c’, l, - ’ c’ P , ’ c/2, 0 ’

V c, l’, ’ + V c, l - l’, - ’ l’ P ,

}

= max | c }

’ l

{ | l /

∈ ≤ ≤ ≤

∈ ≤

δ

δ δ δ δ δ δ

δ δ δ

U

U

}, (52, .2)0 ’

≤ ≤

δ δ

90

Como o valor da solução ótima do PCBGR é dado por V(C, L, D), essa PD apenas

teria utilidade prática em problemas muito pequenos. A necessidade de analisar todas as

possíveis divisões de demandas relacionadas no vetor d com os dois subproblemas δ e δ - δ’

faz com que o número de estados cresça por um fator de ∏ (��� di+1) em relação ao número de

estados do PCBGI correspondente. Desta forma, isso resultaria em grande número de estados

da PD e a “Maldição da Dimensionalidade” levaria ao crescimento exponencial do tempo de

execução com o incremento do número de itens.

5.2.1 RELAXAÇÃO DO ESPAÇO DE ESTADOS DA PROGRAMAÇÃO DINÂMICA

Christofides e Hadjiconstantinou (1995) propuseram uma relaxação do espaço de

estados para produzir limites superiores fortes para o PCBGR. A ideia é associar um peso

inteiro não negativo qi para cada item i e impor que a soma do produto desses pesos pela

demanda dos itens em uma solução não deve exceder o valor Q = ∑ d�. q���� . Desta forma, a

PD relaxada que determina o valor da melhor solução em (c, l) para todo peso não maior do

que o escalar inteiro q = 0,...,Q define-se nas seguintes fórmulas:

Assim sendo, o limite superior do PCBGR é dado por V(C, L, Q). Essa relaxação tende a ser

melhor tratável porque o número de estados em relação ao número de estados da PD para o

PCBGI é apenas multiplicado pelo fator (Q+1). De fato, atribuindo-se pesos zeros para a

maioria dos itens é possível manter o valor de Q relativamente baixo.

O valor do limite superior obtido com essa PD depende fortemente do vetor de pesos

q = [q1,..., qm] escolhido. Com o objetivo de obter bons pesos capazes de determinar limites

superiores de qualidade, Christofides e Hadjiconstantinou propuseram um algoritmo inspirado

no método do subgradiente.

Seja b = [b1,..., bm] o vetor correspondente a solução ótima da PD com certo vetor de

pesos q e de valor Z. Caso bi ≤ di para todo item i, então esse b viável é certamente a solução

ótima do PCBGR. Caso contrário, b é uma solução inviável e Z é um limite superior válido. O

algoritmo de ajuste de pesos faz sua primeira iteração com o vetor de pesos q nulo, isto é, Q

tem valor 0. Em seguida, a PD é executada e retorna uma solução b. As iterações seguintes

atualizam q de acordo com as soluções correntes b, usando a seguinte fórmula:

( ) { } { }

( )

( )

( )

i

i i i = max( | ) (5.3)

}

v c, l, q v 1 i m, c c,

l l, q q 0

{v c , l, q

V c, l

, q {V c’, l, q’ + V c -

= ma cx

≤ ≤ ≤ ≤ ≤ U

U

( )

( ) ( )1

2

’, l, q - q’ c’ P , ’ c/2, q’ q

V c, l’, q’ +

| c 0 }

{ | 0 } (5.4) V c, l - l’, q - q’ l’ P , l’ l/2, q’ q

∈ ≤ ≤ ≤

∈ ≤ ≤

≤

U

91

onde t é um escalar positivo que representa o tamanho do passo. A proposta consiste em

aumentar o peso dos itens que estão em excesso e reduzir o peso dos itens que aparecem

abaixo da demanda. Assim, na proposta original t é dado por:

onde o parâmetro π é inicializado com valor 1.0 e reduzido pela metade a cada 3 iterações até

que este seja menor que ε = 0.05, e ZUB e ZLB são os limites superiores e inferiores,

provenientes da PD relaxada e de um procedimento heurístico, respectivamente.

Silveira e Morabito (2002) e Morabito e Pureza (2010) também utilizam esse

esquema de ajuste de pesos, mas propondo uma melhoria na fórmula de cálculo do passo,

impondo um limite inferior t = 1 admitindo assim que qi seja modificado se bi ≠ di, e

inicializando π com valor 2.0 na formulação a seguir.

Esse algoritmo pode terminar em um dos seguintes casos: (i) o passo se torna muito

pequeno; (ii) o valor de Q está muito grande; (iii) o valor de Z se iguala ao valor da melhor

solução viável conhecida. Neste último caso, essa solução passa a ter um certificado de

otimalidade. De qualquer forma, denomina-se como ZUB o menor valor de Z ao longo das

iterações e este é um limite superior para o PCBGR.

A PD correspondente às fórmulas (5.3) e (5.4) é válida para a variante do PCBGR

sem rotação do item. No entanto, isso pode ser facilmente adaptado para lidar com a variante

que admite essa rotação. Primeiro, a equação (5.3) deve ser substituída por v(c, l, q) =

max({vi | 1 ≤ i ≤ m, (ci ≤ c, li ≤ l) ou (li ≤ c, ci ≤ l), qi ≤ q } ∪ {0}). Em segundo lugar, os

conjuntos de pontos de discretização P1 e P2 utilizados na equação (5.4) devem ser

substituídos por um único conjunto P que correspondem a todas as combinações cônicas

inteiras possíveis de comprimento ou largura dos itens. Portanto, torna-se importante ressaltar

que os algoritmos apresentados em seguida são válidos para ambas variantes, assumindo que

a versão correta do PD seja utilizada.

( )

i i i i i

i

i i i i i

q t b - d se b > d q =

max 0, q - t d - b se b d , (5.5)

+

≤

m 2UB LB i ii 1

1t = π(Z - Z ) / (d - b ) , (5.6)

2 =∑

m 2 UB LB i ii 1

t = max 1, π(Z - Z ) / (d - b ) (5.7)=

∑

92

5.3 LIMITES SUPERIORES PARA O PCBGR POR PROGRAMAÇÃO DINÂMICA E

INTEIRA

Na PD com relaxação do espaço de estados para a obtenção de limites superiores

ZUB, proposta por Christofides e Hadjiconstantinou (1995), a qualidade do limite depende dos

valores atribuídos aos pesos qi dos respectivos itens. Diferentemente da formulação de ajuste

de pesos baseado no método do subgradiente para relaxação Lagrangeana, são propostos

algoritmos X e X2 que calculam estes pesos por PI. Sendo o algoritmo X provadamente ótimo

no sentido de sempre obter os pesos que minimizam o limite superior ZUB e o algoritmo X2

uma generalização da relaxação do espaço de estados que utiliza pesos bidimensionais, estes

são apresentados com maiores detalhes nas subseções seguintes.

5.3.1 ALGORITMO X

Propõe-se um novo algoritmo de ajuste de pesos para a relaxação do espaço de

estados de Christofides e Hadjiconstantinou. Uma característica desse novo algoritmo é

considerar não apenas a solução b da iteração corrente, mas todas as soluções obtidas nas n

iterações já realizadas. Seja bj = [b1j,..., bmj] o vetor da solução de valor Zj gerada na iteração j

com bij sendo o número de vezes que o item i aparece em tal solução. Assume-se que todas

essas n soluções são inviáveis, caso contrário, a solução ótima do PCBGR já teria sido

encontrada. Define-se o seguinte programa linear inteiro chamado de PIX(n):

m

i ii=1

m

ij i ii=1

Min Q = d .q (5.8)

s.a: (b - d )q 1 para todo j = 1,...,n (5.9)

≥

∑

∑

0 e Inteiro (5.10) ≥q

Os novos pesos para a iteração seguinte são dados pela solução de PIX(n). As restrições (5.9)

se baseiam no fato de que a possibilidade do novo vetor de pesos q melhorar ZUB está

condicionada a eliminação de todas as n soluções geradas anteriormente do conjunto de

soluções da PD relaxada. No algoritmo X descrito a seguir, maxiter e Qmax são parâmetros

limitantes do número máximo de iterações e o do valor máximo permitido para Q e a saída

Certopt notifica se há um certificado de otimalidade.

Algoritmo X (maxiter, Qmax) 1. n = 1, q = 0, ZUB = ∞; 2. Resolva a PD relaxada com o vetor q, obtendo uma solução bn de valor Zn; 3. Se (Zn < ZUB) então ZUB = Zn; 4. Se (bn viável) então Retorna (ZUB, Certopt = True); 5. Resolva o PIX(n);

93

6. Se (PIX(n) inviável) então Retorna (ZUB, Certopt = False); 7. Atualize vetor q e Q com a solução ótima de PIX(n); 8. n = n + 1; 9. Se (n > maxiter ou Q > Qmax) então Retorna (ZUB, Certopt = False); 10. Volta ao passo 2;

Fim X

Lema 1. Mesmo se maxiter = ∞ e Qmax = ∞, o algoritmo X termina em um número finito de

iterações.

Prova: A definição de PIX(n) garante que a solução bn+1 é distinta das soluções bj , 1 ≤ j ≤ n.

Como existe um número finito de soluções, o algoritmo deve parar. □

Teorema 1. Se maxiter = ∞ e Qmax = ∞, algoritmo X sempre retorna ZUB = ZUBopt, que é o

menor limite superior possível de ser encontrado pela PD relaxada com qualquer vetor de

pesos q. Além disso, a iteração da PD relaxada que encontra ZUBopt utiliza o menor valor de

Q que obtém esse limite superior.

Prova: Pelo Lema 1, o algoritmo X para. Se X para com um certificado de otimalidade,

certamente ZUB = ZUBopt. Caso contrário, X parou na iteração n porque PIX(n) é inviável.

Suponha que o ZUB retornado não é ótimo, isto é, ZUB > ZUBopt. Neste caso, suponha que

exista um vetor de pesos inteiros qopt que produza um limite ZUBopt < ZUB. Não é possível que

∑ (��� bij - di).qopt i < 1 para algum j, 1 ≤ j ≤ n. Caso contrário, a solução bj com valor Zj ≥ ZUB

seria uma solução da PD relaxada com pesos qopt. Portanto, qopt é viável para PIX(n).

Contradição.

Seja n’ a primeira iteração que produziu a solução bn’ de valor Z n’ = ZUBopt. Se n’ =

1, então o valor de Q era 0 nessa iteração. Se n’ > 1, o vetor de pesos q da PD relaxada na

iteração n’ foi obtido da solução ótima de PIX(n’-1). Para cada solução bj, 1 ≤ j ≤ n-1, esta

tem valor Zj > ZUBopt. Logo, qualquer vetor de pesos q que produzir uma solução de valor

ZUBopt deve satisfazer ∑ (��� bij - di).qi ≥ 1, para todo j =1,...,n’-1. Portanto, Q = ∑ d�. q�

��� pode

não ser menor do que o valor obtido na solução do PIX(n’-1). □

Na grande maioria das instâncias da literatura testadas, o algoritmo X com maxiter =

∞ e Qmax = ∞ termina em menos de 10 iterações e com valores de Q inferiores a 20.

Entretanto, em algumas instâncias, o número de iterações e os valores de Q podem crescer

consideravelmente, tornando o algoritmo lento demais em sua execução. Além disso, nesses

casos, o valor final ZUB não é significativamente melhor do que os valores de ZUB obtidos nas

primeiras iterações, quando os valores de Q eram razoávelmente pequenos. Para impedir essa

94

Padrões de Corte Inviáveis CW4

situação, pode-se truncar o algoritmo X fazendo uso dos parâmetros maxiter e Qmax, que

limitam o número máximo de iterações e um valor máximo para Q. Este último limite é

implementado da seguinte forma: ao se resolver PIX(n), caso o Q obtido seja maior que Qmax,

o algoritmo finaliza retornando (Zmin, Certopt = false). O Teorema 2 enuncia que o algoritmo

X ainda obtém solução ótima para determinado Qmax. Sua prova é omitida por ser análoga a

do Teorema 1.

Teorema 2. Suponha que o algoritmo X seja executado com maxIter = ∞ e um limite Qmax.

Nesse caso, o ZUB retornado sempre vai ser igual ao melhor limite superior possível de ser

encontrado pela PD relaxada com qualquer vetor de pesos q tal que Q = ∑ �� . ����� ≤ Qmax.

FIGURA 5.1 – Padrões de Corte Inviáveis da Instância CW4 com Algoritmo X.

(a) (b)

(c) (d)

95

Para ilustrar o algoritmo X para o caso sem rotação, é introduzida uma execução

detalhada sobre a instância clássica CW4 do PCBGR sem peso, apresentada em (FAYARD et

al., 1998). Essa instância totaliza 86 itens demandados com valores distintos às suas medidas

de área, m = 38, C = 465 e L = 387.

O algoritmo X inicia resolvendo o PD com o vetor q nulo e o escalar Q = 0 e isso é

equivalente a resolver o PCBGI. A solução ótima obtida com valor Z1 = 6551 é mostrada na

Figura 1 (a). Nesses padrões, o excesso de produção de algum item é ilustrado com a presença

de itens coloridos. O vetor de solução b1 tem como componentes não nulos b12 = 3, b18 = 6 e

b25 = 1 e com as respectivas demandas d12 = 6, d18 = 2 e d25 = 3, o item 18 ultrapassa em 4

itens sua demanda. Observe no PIX(1) mostrado a seguir, assim como os demais, que as

variáveis correspondentes a itens que não aparecem em alguma solução bj, 1 ≤ j ≤ n, podem

ser omitidas dos respectivos PIX(n) uma vez que têm valor zero em qualquer solução ótima.

12 18 25

12 18 25

Min Q = 6q + 2q + 3q s.a: - 3q + 4q - 2q 1 ≥

≥q 0 e Inteiro

A solução ótima de PIX(1) fornece um vetor de pesos onde q18 = 1 e valor Q = 2. Na

sequência, a PD relaxada na iteração 2 obtém a solução de valor Z2 = 6183 que pode ser

conferida na Figura 1 (b). Verifica-se que o item 28 é produzido 9 vezes mas sua demanda é

apenas 4. PIX(2) é descrito a seguir e tem solução ótima Q = 8 com q18 = 2 e q28 = 1.

12 18 25 28

12 18 25 28

12 18 25 28

Min Q = 6q + 2q + 3q 4q s.a: - 3q + 4q - 2q - 4q 1

- 6q - 2q - 3q 5q 1

0 e Inteiro

+

≥

+ ≥

≥q

A iteração 3 produz a solução mostrada na Figura 1 (c), com Z3 = 6238. Como o item

26 tem d26 = 7, o PIX(3) construído a seguir tem solução ótima de valor Q = 26 com q18 = 7 e

q28 = 3.

12 18 25 26 28

12 18 25 26 28

12 18 25 26 28

12 18 25 26 28

Min Q = 6q + 2q + 3q + 7q + 4q s.a: - 3q + 4q - 2q - 7q - 4q 1

- 6q - 2q - 3q - 7q 5q 1 - 3q + q - 2q - 6q - 2q 1

0 e Intei

≥

+ ≥

≥

≥q ro

A solução obtida na iteração 4 com Z4 = 6233 é representada na Figura 1 (d) e

conduz ao PIX(4) como segue.

96

12 18 25 26 28

12 18 25 26 28

12 18 25 26 28

12 18 25 26 28

12 18

Min Q = 6q + 2q + 3q + 7q + 4q s.a: - 3q + 4q - 2q - 7q - 4q 1

- 6q - 2q - 3q - 7q 5q 1 - 3q + q - 2q - 6q - 2q 1 - 2q + q - 2

≥

+ ≥

≥

25 26 28

q - 6q - 3q 1

0 e Inteiro ≥

≥q

Como o PIX(4) é inviável, o algoritmo X termina com ZUB = Z2 = 6183. Ressalta-se

ainda que o tempo de resolução destes programas inteiros é praticamente insignificante em

relação ao tomado pela PD.

5.3.2 ALGORITMO X2

Com o objetivo de obter limites superiores ainda mais fortes por PD, introduz-se aqui

uma generalização do conceito de relaxação de espaço de estados de Christofides e

Hadjiconstantinou (1995). A ideia é que cada item i passa ser associado a um peso inteiro não

negativo bidimensional qi = (q1i, q2i). Define-se então q = [q1 = (q11, q21),..., qm = (q1m, q2m)],

q1 = [q11,..., q1m] e q2 = [q21,..., q2m]. A nova PD relaxada deve impor que a soma do produto

dos respectivos pesos dos itens pelas suas demandas em uma solução não deve exceder o

valor bidimensional Q = (Q1 = ∑ d���� .q1i, Q2 = ∑ d�

��� .q2i). A formulação de recorrência é

similar à expressa em (5.3) e (5.4), mas nessa nova interpretação em que q representa um

vetores de pesos bidimensionais. Em tais fórmulas, também, são consideradas as combinações

de todos os pesos não maiores que os escalares inteiros q1 = 0,...,Q1 e q2 = 0,...,Q2. Sendo

assim, o limite superior do PCBGR é dado por V(C, L, (Q1, Q2)) e o número de estados passa

a ser (Q1+1).(Q2+1) vezes maior, se comparado ao número de estados da PD para o PCBGI.

A adaptação do algoritmo X para os pesos bidimensionais exige a definição de um

novo problema de otimização. A atualização desse vetor bidimensional q pode ser dada pelo

seguinte Programa Inteiro Quadrático denominado PQIX2(n):

1 2m

1 i 1ii=1

Min (Q +1).(Q +1) (5.11)

s.a: Q = (D .q ) (5∑

m

2 i 2ii=1

m

ij 1i 1 ji=1

.12)

Q = (D .q ) (5.13)

(b .q ) - Q + M(1 - y ) 1 para todo j = 1,...,n (5.1

≥

∑

∑

m

ij 2i 2 ji=1

1

4)

(b .q ) - Q + My 1 para todo j = 1,...,n (5.15)

y = 1 (5.16)

≥∑

j

, 0 e Inteiro (5.17) y Binário

≥1 2q q (5.18)

97

No modelo PQIX2(n), a função objetivo quadrática busca minimizar o número de

estados na PD relaxada e existem 2(m+1) variáveis inteiras não negativas e n variáveis

binárias. Para cada i, 1 ≤ i ≤ m, as variáveis individuais q1i e q2i representam as duas

dimensões de pesos do item i. As igualdades (5.12) e (5.13) são as definições das variáveis Q1

e Q2 em função dos respectivos vetores de variáveis q1 e q2. Para cada j, 1 ≤ j ≤ n, a variável

binária yj indica que a solução bj da PD relaxada deve ser eliminada pela primeira dimensão

de pesos (yj = 1) ou pela segunda dimensão (yj = 0). Estas variáveis aparecem nas restrições

(5.14) e (5.15) e os coeficientes M devem grandes o suficiente para garantir que uma solução

bj nunca precisa ser eliminada por ambas as dimensões. A restrição (5.16) não é essencial,

mas ajuda reduzir o grau de simetria de PQIX2(n), indicando que a primeira solução deve ser

eliminada pelos pesos de q1.

Define-se o algoritmo X2 como sendo a generalização do algoritmo X para pesos

bidimensionais, que agora são atualizados pela solução de PQIX2(n).

Algoritmo X2 (maxiter, Qmax, ZUB) 1. n = 1, q = [0, 0]; 2. Resolva a PD relaxada com o vetor q, obtendo uma solução bn de valor Zn; 3. Se (Zn < ZUB) então ZUB = Zn; 4. Se (bn viável) então Retorna (ZUB, Certopt = True); 5. Resolva o PQIX2(n); 6. Se (PQIX2(n) inviável) então Retorna (ZUB, Certopt = False); 7. Atualize vetor q = [q1, q2] e Q = (Q1, Q2) com a solução ótima de PQIX2(n); 8. n = n + 1; 9. Se (n > maxiter ou Q1 > Qmax ou Q2 > Qmax) então Retorna (ZUB, Certopt = False); 10. Volta ao passo 2;

Fim X2

A prova do teorema 3 é análoga ao do Teorema 1.

Teorema 3. Se maxiter = ∞ e Qmax = ∞, algoritmo X2 sempre retorna ZUB2 = ZUB2opt, que é o

menor limite superior possível de ser encontrado pela PD relaxada com qualquer vetor

bidimensional de pesos q. Além disso, a iteração da PD relaxada que encontra ZUB2opt, utiliza

pesos que fazem a quantidade (Q1+1).(Q2+1) ser a menor possível dentre todos os pesos que

podem obter esse limite superior.

Teorema 4. ZUB2opt ≤ ZUBopt e há instâncias onde esta desigualdade é estrita.

Prova: Para obter um limite igual a ZUBopt usando uma PD com pesos bidimensionais,

bastaria usar valores de q1 iguais aos pesos ótimos da PD com pesos unidimensionais q* e

manter os valores em q2 iguais a 0. Para mostrar que a desigualdade pode ser estrita, dá-se um

exemplo com a instância definida por R = (6, 1), m = 2, p1 = (3, 1), d1 = 1, v1 = 3, p2 = (2, 1),

98

d2 = 2 e v2 = 2. Executando o algoritmo X, obtém-se b1 = [2, 0] e Z1 = 6 na primeira iteração.

Após a resolução de PIX(1), a segunda iteração utiliza q* = [1, 0] e produz a solução b2 = [0,

3] com Z2 = 6. Sendo assim, o PIX(2) é o seguinte:

1 2

1 2

1 2

Min q + 2q s.a: q - 2q 1

- q + q 1 ≥

≥

0 e Inteiro ≥q

Como PIX(2) é inviável, o algoritmo X terminaria com ZUB = ZUBopt = 6. Entretanto, o

algoritmo X2 terminaria por otimalidade com ZUB = ZUB2opt = 5. Esse limite é obtido com os

pesos vetores q1 = [1,0] e q2 = [0,1]. □

Existem softwares disponíveis para resolver problemas de PI com função objetivo

quadrática. Entretanto, por simplicidade e para evitar a possibilidade dessa resolução

demandar um tempo computacional maior, opta-se nos experimentos computacionais em

simplificar a função objetivo de PQI(n) para

Min Q1 + Q2. (5.19)

Adotando (5.19) como função objetivo sujeito as restrições (5.12) - (5.18), formula-

se o problema de PI denominado PIX2(n). Note que mesmo com essa simplificação, o

algoritmo X2 usando PIX2(n) ainda encontra o melhor limite superior possível ZUB2opt se

maxiter = ∞ e Qmax = ∞. No entanto, esse limite possivelmente vai ser obtido com um conjunto

de pesos bidimensionais que não minimizam o número de estados na PD.

Consequentemente, pesos bidimensionais podem obter limites superiores mais fortes,

mas também as relaxações da PD podem ser mais demoradas para serem resolvidas. Por essa

razão, torna-se mais interessante utilizar os pesos bidimensionais apenas quando o algoritmo

X finalizar sem o certificado de otimalidade para a instância. Assim sendo, X2 inicializa com

as n soluções inviáveis bj, 1 ≤ j ≤ n, encontradas anteriormente pelo algoritmo X. Isto

significa que em vez de iniciar com q1 = 0 e q2 = 0, considera-se as n soluções documentadas

para atribuir a tais vetores os respectivos pesos da solução de PIX2(n). Isto é coerente porque

X2 somente pode melhorar o limite superior ZUB produzido pelo X usando pesos que

eliminem do relaxamento do espaço de estados todas essas n soluções.

Considerando o desenvolvimento do algoritmo X2 na instância CW4, esse é

inicializado com as 4 soluções inviáveis encontradas pelo algoritmo X, então o primeiro

problema inteiro resolvido é o PIX2 (4) como segue.

99

Padrão de Corte Ótimo CW4

1 2

1_12 1_ 18 1_25 1 _ 26 11 _ 28

Min Q + Q s.a: 6q 2q 3q 7q 4q Q = + + + +

2_12 2 _18 2_25 2 _ 26 2 _ 28

1_12 1_ 18 1_25 1

2_12 2 _ 18 2_25 1

1_ 28

1

1 2

2

2

6q 2q 3q 7q 4q

3q 6q q - M(1- y ) 1 3q 6q q - My 1

9q

Q

- M(1 - y

= Q

QQ ) 1

9

+ + + +

+ + + ≥

+ + + ≥

+ ≥

2 _ 28 2

1_12 1 _18 1_25 1 _ 26 1_ 2

2

1

2

8 3

2_12 2 _ 18 2_25 2 _ 26 2 _ 28 3

1_12 1 _18 1_25 1 _ 26 1 _ 2 18 4

q - My 1 3q 3q 1q 1q 2q - M(1 - y ) 1

3q 3q 1q 1q 2q - My 1 4q 3q 1q 1q 1q - M(1 - y )

QQ

QQ 1

4q

+ ≥

+ + + + + ≥

+ + + + + ≥

+ + + + + ≥

2_12 2 _18 2_25 2 _ 26 2 _ 28 4

1

2

3q 1q 1q 1q - My 1 y 1

, 0 e Inteiro y Binário

Q

+ + + + + ≥

=

≥1 2q q

A solução ótima de PIX2 (4) tem as variáveis binárias y1 = 1, y2 = 0, y3 = 1 e y4 = 1 e

os pesos individuais não nulos são q1_18 = 1 e q2_28 = 1 produzindo Q1 = 2 e Q2 = 4. Desta

forma, a PD relaxada com esses pesos bidimensionais encontra a solução viável apresentada

na Figura 5.2 de valor Z5 = 6175. Essa solução é certificada como sendo ótima, encerrando a

execução do algoritmo X2.

FIGURA 5.2 – Padrão de Corte Ótimo da Instância CW4 com Algoritmo X2.

5.4 LIMITES INFERIORES PARA O PCBGR POR GRASP, PROGRAMAÇÃO

DINÂMICA E INTEIRA

O esforço computacional a cada execução da PD com os algoritmos X e X2 justifica-

se não somente pelos fortes limites superiores ZUB obtidos, mas também pela qualidade dos

100

múltiplos padrões ótimos ou subótimos encontrados pela PD relaxada para cada possível corte

horizontal ou vertical no retângulo (C, L). Sabendo que um limite superior ZUB é dado pelo

padrão de corte de maior valor, se a PD relaxada dos respectivos algoritmos X e X2

produzirem uma solução viável no decorrer do processo com ZUB = ZLB, é atribuído o

certificado de otimalidade a essa solução e o programa termina. Senão, busca-se melhorar o

limite inferior ZLB utilizando as seguintes estratégias: (i) rodar a instância no algoritmo RG2D

após o X2, apenas se o gap entre o ZUB e o ZLB corrente for maior que o limitante Gapmax; (ii)

utilizar uma heurística baseada na relaxação do espaço de estados da PD com pesos

bidimensionais; (iii) pesquisar nos múltiplos padrões ótimos ou subótimos encontrados na

matriz da PD, para cada possível corte horizontal ou vertical no retângulo (C, L), por uma

solução que atualize esse limite; (iv) executa-se um procedimento de viabilização em padrões

inviáveis e com valor superior ao ZLB corrente, que consiste na substituição de itens com

produção acima por outros itens com demanda não atendida. Com as versões do RG2D

apresentadas no Capítulo 4, nas próximas subseções são esclarecidos detalhes sobre os

métodos (ii), (iii) e (iv) utilizados na tentativa de incrementar o ZLB.

5.4.1 HEURÍSTICA X2H

Supondo que se tenha escolhido um determinado vetor de pesos unidimensional q

tenha vários itens com peso positivo. Para a PD relaxada encontrar um limite superior válido,

deve-se resolver V(C, L, Q) com a recursão (5.3) - (5.4), onde Q = ∑ (��� di.qi). Esse valor de

Q se faz necessário porque é possível que a solução ótima do PCBGR use exatamente di

cópias de cada item com peso positivo. Porém, na prática, é muito improvável que isso

aconteça. Isso significa que calculando V(C, L, Qheu), onde Qheu é um escalar inteiro não

negativo de valor menor ou igual a Q, é provável que a solução ótima do PCBGR não seja

eliminada. Além disso, uma vez que muitas soluções inviáveis são eliminadas, há uma chance

de encontrar boas soluções viáveis na PD relaxada. O algoritmo proposto X2H é uma

heurística baseada nessa observação, a ser usada depois que X2 encerra sem um certificado de

otimalidade para as soluções da PD relaxada nessa fase.

Sendo assim, o algoritmo X2H utiliza os pesos bidimensionais e é inicializado com

todas as soluções inviáveis encontradas ao longo da execução dos algoritmos X e X2, nos

quais todas elas apresentam valor maior ou igual a ZUB. A ideia consiste em fixar valores

arbitrários para Qheu = (Q1heu, Q2heu) e então escolher os pesos q resolvendo o seguinte

modelo, chamado PIX2H (n, Qheu):

101

m

i 1i 2ii=1m

ij 1i 1heu ji=1

Min d .(q q ) (5.20)

s.a: (b .q ) - Q + M(1 - y ) 1 para todo j = 1,...,n (5.21)

+

≥

∑

∑

m

ij 2i 2heu ji=1

1

(b .q ) - Q + My 1 para todo j = 1,...,n (5.22)

y = 1 (5.23)

≥∑

j

, 0 e Inteiro (5.24) y Binário (5.

≥1 2q q25)

Dependendo do Qheu escolhido, PIX2H(n, Qheu) pode ser viável mesmo com PIX2(n)

inviável. Isto acontece porque PIX2H(n, Qheu) pode ter soluções tais que Q1 = ∑ (��� di.q1i) >

Q1heu ou Q2 = ∑ (��� di.q2i) > Q1heu. Como consequência, a solução de V(C, L, Qheu) por PD não

estabelece um limite superior válido. Por outro lado, PIX2H(n, Qheu) consegue eliminar da PD

conjuntos de soluções indesejáveis bem maiores do que os modelos exatos poderiam fazer e,

possivelmente, encontrar soluções viáveis capazes de melhorar ZLB, o melhor limite inferior

corrente.

O procedimento DescidaX2H descrito a seguir é uma busca por uma solução viável

para um valor bidimensional fixo de Qheu. De início, utiliza as n soluções inviáveis

disponíveis ao final do algoritmo X2 e outras soluções inviáveis encontradas pela PD são

incorporadas no PIX2H(n, Qheu) para serem eliminadas nas próximas iterações. O

procedimento é chamado de "descida" porque os valores sucessivos de Zn são suscetíveis a

diminuir e este procedimento para quando Zn ≤ ZLB.

Procedimento DescidaX2H (maxiter, Qheu, n, ZLB) 1. Resolve PIX2H(n, Qheu); 2. Se (PIX2H(n, Qheu) inviável ou n > maxiter) então Retorna (ZLB); 3. Atualize o vetor q com a solução ótima de PIX2H(n, Qheu); 4. n = n + 1; 5. Resolva a PD relaxada com o vetor q e Qheu, obtendo uma solução bn de valor Zn; 6. Se (bn viável e Zn > ZLB) então ZLB = Zn; 7. Volta ao passo 1;

Fim DescidaX2H

O algoritmo X2H consiste em chamar DescidaX2H para diferentes valores de Qheu. A

seleção destes valores é descrita como segue. Sejam Q1X2 e Q2X2 os últimos valores para Q1 e

Q2 menores que Qmax obtidos com a execução do algoritmo X2. Quando X2 termina porque

PIX2(n) é inviável, esses valores correspondem à solução de PIX2(n-1). Visto que a execução

do procedimento DescidaX2H para todos os possíveis pares de inteiros positivos Q1heu e Q2heu,

tais que Q1heu ≤ Q1X2 e Q2heu ≤ Q2X2, representa um esforço computacional considerável nas

102

respectivas relaxações da PD, considera-se apenas a utilização de Qheu = (Q1X2, Q2X2) na

tentativa de encontrar uma solução que atualize ZLB.

5.4.2 MÚLTIPLOS PADRÕES NA MATRIZ DA PROGRAMAÇÃO DINÂMICA

Os algoritmos X, X2 e X2H, tal como apresentados antes, somente podem encontrar

soluções viáveis que correspondam à solução ótima de uma PD. De fato, os algoritmos X e

X2 apenas podem encontrar soluções viáveis na sua última iteração e apenas para casos em

que ZUBopt e ZUB2opt, respectivamente, são iguais ao valor da solução ótima do PCBGR. Seria,

então, conveniente usar o esforço computacional significativo já gasto na resolução de cada

PD para também tentar encontrar boas soluções viáveis a cada iteração desses algoritmos.

A primeira observação é que, de acordo com a equação (5.4), calcula-se V(C, L, Q)

como o melhor valor de 1 + | P1 | + | P2 | soluções, correspondendo a todas as formas de corte

horizontal ou vertical do objeto original. Pode acontecer que algumas dessas soluções sejam

viáveis, mesmo que a melhor dessas soluções com valor Zn seja inviável. O esforço

computacional para verificar cada uma dessas soluções é desprezível em comparação com o

tempo gasto pela PD. Além disso, a verificação das soluções subótimas para valores menores

do que Q é apropriada em vários casos, pois bons limites inferiores ZLB são obtidos desta

forma com os algoritmos X, X2 e X2H.

É importante ressaltar que com a aplicação desta proposta, o algoritmo X retorna

ainda na terceira iteração a solução ótima da instância CW4 ilustrada na Figura 5.2.

5.4.3 HEURÍSTICA DE VIABILIZAÇÃO

Esta última estratégia consiste em providenciar mudanças nos padrões de corte

referentes a algumas soluções ótimas ou subótimas da PD, que têm valor maior do que ZLB e

são inviáveis com poucos itens excedendo suas demandas. O objetivo da heurística de

viabilização é reparar esses padrões de corte, substituindo os itens em excesso por itens com a

demanda disponível com o intuito de torná-los factíveis. Essa recomposição tende a diminuir

o valor desta solução mas também considera a possibilidade do novo valor ser maior do que

ZLB atual ou até igual ao ZUB, garantindo assim um certificado de otimalidade.

Em Morabito e Pureza (2010) é proposta uma heurística de viabilização onde os

espaços ocupados pelos itens em excesso e, possivelmente, áreas improdutivas do objeto no

entorno destes, são substituídos por arranjos de um ou mais itens distintos, selecionados de

forma a proporcionar maior valor na solução.

Nessa mesma diretriz, propõe-se também um procedimento heurístico que não

somente verifique a possibilidade de substituições homogêneas, mas também realiza trocas

103

heterogêneas com as versões do RG2D. Este procedimento é utilizado em qualquer padrão

inviável obtido com os algoritmos X, X2 e X2H que apresente no máximo 2 itens produzidos

além da demanda. É importante ressaltar que essa viabilização não considera a possibilidade

de composições na horizontal ou na vertical de itens adjacentes com produção acima da

demanda, o aproveitamento de espaços considerados perdas do objeto e o número máximo de

itens cujos espaços podem reaproveitados é ajustável nesse procedimento.

Sendo E o conjunto dos itens com demanda em excesso com |E| ≤ 2 e I o conjunto

dos itens com demanda não atendida no padrão corrente. O processo inicia-se com um item de

E sendo selecionado aleatoriamente se |E| = 2. Caso contrário, o conjunto E é unitário e não

há necessidade de sorteio. Definido então as dimensões do retângulo a ser substituído a partir

das condições supracitadas, as tentativas de permutações homogêneas em no máximo 2

estágios são priorizadas e, se ainda houver algum item de I com medida de área menor ou

igual à perda interna da melhor troca homogênea, o procedimento chama o RG2D para

produzir uma possível substituição heterogênea de maior valor. Assim como na simples

substituição homogênea do item considerando o corte guilhotina em dois estágios, o RG2D

trata a viabilização como um PCBGR com o objeto apresentando as dimensões desse item em

excesso.

É importante destacar que cada execução do RG2D na heurística de viabilização é

rápida, porque considera um espaço restrito e apenas os itens que são pequenos o suficiente

para caber nesse espaço. No entanto, o quantitativo de padrões inviáveis obtidos na matriz da

PD é elevado e o tempo gasto em cada viabilização não é desprezível. Consequentemente,

torna-se conveniente utilizar essa heurística apenas em soluções que são realmente quase

viáveis com uma quantidade bem pequena de itens excedentes.

5.5 ALGORITMO X2D

Com os algoritmos X utilizando PI para determinar os pesos ótimos da PD com

relaxação do espaço de estados, X2 sendo uma generalização de X que utiliza pesos

bidimensionais na relaxação dos espaços de estados da PD, G2D em sua versão reativa que

inclui a calibragem dos parâmetros α e ψ, e X2H consistindo de uma heurística primal

modelada a partir de X2, uma proposta de composição destes algoritmos denominada X2D é

apresentada para resolução do PCBGR nas variantes já destacadas neste trabalho. A utilização

destes algoritmos na presente ordem é distinguida numa composição de 4 fases distintas e o

algoritmo é inicializado com os dados da instância e os limitantes de parada por iterações

(maxiter) ou tempo limite de execução (TLim) e que condiciona a execução da fase 3 (Gapmax),

conforme pseudocódigo a seguir.

104

Algoritmo X2D (maxiter, TLim, GapMax) 1. Determine os pontos de discretização dos conjuntos P1 e P2; 2. n = 1, q = 0, T = 0, ZUB = ∞, ZLB = 0; 3. Enquanto (n ≤ maxiter e T ≤ TLim) faça 4. Execute o Algoritmo X e, se possível, atualize Certopt, ZUB e ZLB; 5. Se (Certopt = False) então 6. Execute o Algoritmo X2 e, se possível, atualize Certopt, ZUB e ZLB; 7. Se (Certopt = False e (ZUB - ZLB)/ZUB > GapMax) então 8. Execute o Algoritmo RG2D e, se possível, atualize Certopt e ZLB; 9. Se (Certopt = False e Q > 0) então 10. Execute o Algoritmo X2H e, se possível, atualize Certopt e ZLB; 11. Retorna (Certopt, ZUB, ZLB);

Fim X2D

5.6 RESULTADOS COMPUTACIONAIS

Nos testes realizados com o algoritmo primal-dual completo X2D, impondo o

limitante de tempo TLim = 600 segundos, essa execução pode ser especificada nas seguintes

fases:

1. Executar o algoritmo X com maxiter = 100 e Qmax = 20. A heurística de

viabilização usando RG2D sobre as soluções da PD Relaxada ótimas e subótimas, como

descrito anteriormente, é chamada em cada iteração. Com os limites inferiores e superiores

sendo produzidos e atualizados a cada iteração, se ZLB = ZUB, o algoritmo retorna uma

solução com certificado de otimalidade.

2. Executar Algoritmo X2 com maxiter = 100 e Qmax = 30, incluindo também

chamadas heurística de viabilização usando RG2D. X2 é inicializado com as soluções

inviáveis encontradas pelo algoritmo X, conforme descrito na subseção 5.3.2. Com o

propósito de melhorar os limites inferiores e superiores, se obtiver ZLB = ZUB, o algoritmo X2

para com certificado de otimalidade.

3. Se (ZUB - ZLB)/ZLB > 0.003, executar a heurística primal pura RG2D em rodada

única com a seguinte parametrização: semente 123, φ = 5, δ = 10, Α = {0.1, 0.2, 0.3, 0.4, 0.5},

Ψ = {0.01, 0.02, 0.03, 0.04, 0.05}, Α’ = {αR, αR ± 0.025, αR ± 0.05}, iterC = 1000 e iterR =

5000, produzindo 50000 iterações, pitens = 50% na primeira metade das iterações e pitens =

10% nas demais. Na possível atualização do limite inferior via RG2D, se ZLB = ZUB, encerrar

com certificado de otimalidade.

4. Executar o algoritmo primal X2H conforme descrito na subseção 5.4.1. Se ZLB =

ZUB, parar com certificado de otimalidade. Caso contrário, a última fase do X2D termina com

os valores finais de ZLB e ZUB e a melhor solução gerada.

Os limites superiores ZUB podem ser obtidos somente nas fases 1 e 2. As fases 3 e 4

destinam-se a melhorar os limites inferiores ZLB. A heurística primal pura RG2D é chamada

105

após a execução do algoritmo X2 e se a instância apresentar relativa dificuldade para os

métodos baseados em DP, como indicado por um intervalo entre os limites inferior e superior

maiores que 0.3%. No entanto, por razões de comparação, também são apresentados os

resultados que o RG2D obtém como uma heurística autônoma em todas as instâncias.

O algoritmo X2D foi executado uma vez para cada instância e, em todas as instâncias,

a semente de números aleatórios foi definida como 123. Por outro lado, para testar RG2D de

forma autônoma, foram realizadas 10 execuções para cada instância com a semente retirada

do clock do sistema.

Os algoritmos X, X2, RG2D e X2H e a composição destes, indicada por X2D, foram

implementados em linguagem C/C++ e compilados no Microsoft Visual C++ 2010 Express,

os modelos de PI foram resolvidos pelo CPLEX 12.5.1 e os testes foram realizados em um

computador com núcleo único de um processador Intel(R) Core(TM) i7-4790 3.6GHz, com

16Gb de RAM e Windows 8 de 64 bits.

Os testes são realizados em instâncias reconhecidas na literatura do PCBGR e

fornecidas nas páginas do ESICUP e do repositório de instâncias OR-Library,

http://paginas.fe.up.pt/~esicup/datasets) e http://people.brunel.ac.uk/~mastjjb/jeb/info.html, e

no endereço eletrônico http://www.laria.u-picardie.fr/hifi/OR-Benchmark, conforme

especificado no Capítulo 4.

Neste momento, os problemas testados são divididos em quatro conjuntos de

instâncias. O primeiro conjunto de 30 instâncias corresponde aos exemplos mais clássicos da

literatura, sendo 14 com peso e o restante sem peso. O segundo conjunto contém 450

instâncias aleatórias sem peso, geradas por Morabito e Pureza (2010). Estas instâncias são

divididas em 3 classes: as instâncias na classe 1 são moderadamente restritas, apresentando

demandas relativamente grandes; as da classe 2 são mais restritas com demandas pequenas; e

as instâncias da classe 3 são altamente limitadas e possuem demandas unitárias. Cada classe é

dividida em 10 grupos de 15 instâncias e cada grupo é denotado por R_m_Κ, onde o número

de itens distintos m pode ser 10, 20, 30, 40 ou 50 e a letra Κ é substituída por S ou L,

representando itens pequenos ou grandes, respectivamente. O terceiro conjunto é constituído

das instâncias propostas por Alvarez-Valdés et al. (2002a) e iniciadas com a sigla APT.

Consideradas problemas de grande porte e identificadas segundo valor de utilidade dos itens,

as APT40-APT49 são referentes ao caso com peso e as APT30-APT39 sem peso. O último

conjunto é formado pelas instâncias sem peso gcut1-gcut13, propostas inicialmente por

Beasley (1985) para o PCBGI, mas com demanda unitária dos itens.

106

Os algoritmos propostos X2D e RG2D são comparados com o algoritmo heurístico

DP_AOG proposto por Morabito e Pureza (2010), nas instâncias do primeiro e segundo

conjunto, para variante sem rotação do PCBGR. Nas instâncias do terceiro e quarto conjunto,

as comparações, também do caso não rotacionado, são feitas com o algoritmo exato A1

proposto por Dolatabadi et al. (2012). Vale ressaltar ainda, que os tempos estão em segundos

e, conforme explicado no Capítulo 4, os algoritmos DP_AOG e A1 rodaram em

processadores 3.5 e 3.1 vezes mais lentos, nessa ordem.

Nas Tabelas 5.1-5.6 encontram-se os resultados dos algoritmos em destaque para a

variante sem rotação do PCBGR, discriminado de acordo com os respectivos conjuntos de

instâncias. As colunas das Tabelas 5.1 e 5.2, do primeiro conjunto de instâncias, são as

seguintes: nome da instância; o número de itens distintos; a melhor solução encontrada pelo

DP_AOG; o tempo que o DP_AOG levou para encontrar sua melhor solução e o tempo de

execução total com limite de 1800 segundos; o limite superior obtido pelo X2D; a melhor

solução obtida pelo X2D; o tempo que o X2D levou para encontrá-la e seu tempo total de

execução; a melhor solução em 10 execuções do RG2D como uma heurística autônoma, o

tempo para encontrar esta solução e seu tempo total. Um único * em um valor de solução

indica que ele corresponde ao ótimo conhecido na literatura e um duplo * significa que a

solução é certificada como ótima pelo método que a produziu.

TABELA 5.1 – Resultados nas Instâncias Clássicas sem Rotação e com Peso.

A partir dos resultados nas Tabelas 5.1 e 5.2, pode ser observado que tanto o

DP_AOG como o X2D retornam todas as soluções ótimas. No entanto, em alguns casos X2D

Instâncias AlgoritmosNome m DP_AOG Tempo ZUB X2D Tempo RG2D TempoChW1 7 **244 <0.1 0.1 244 **244 0.1 0.1 *244 <0.1 4.3

ChW2 10 **2892 0.8 38.4 2892 **2892 0.3 0.3 *2892 0.6 5.5

ChW3 20 **1860 0.1 19.9 1860 **1860 <0.1 0.1 *1860 <0.1 11.8

CW1 25 **6402 1.1 25.6 6402 **6402 <0.1 <0.1 *6402 <0.1 11.9

CW2 35 *5354 0.7 1118.8 5354 **5354 <0.1 0.4 *5354 0.1 11.3

CW3 40 **5689 0.5 26.9 5689 **5689 <0.1 <0.1 *5689 14.1 17.1

CW4 39 **6175 1.3 46.8 6175 **6175 0.1 0.2 *6175 9.4 16.3

CW5 35 **11659 0.8 1268.5 11659 **11659 0.1 0.1 *11659 7.7 14.9

CW6 55 **12923 33.3 890.6 12923 **12923 0.1 0.1 12651 1.1 28.2

CW7 45 **9898 4.1 10.7 9898 **9898 <0.1 <0.1 *9898 2.0 21.3

CW8 60 **4605 20.8 340.5 4605 **4605 <0.1 0.1 *4605 <0.1 34.4

CW9 50 **10748 7.0 121.3 10748 **10748 0.1 0.1 *10748 0.3 25.4

CW10 60 **6515 2.8 182.2 6515 **6515 0.1 0.1 6471 23.6 29.7

CW11 60 **6321 2.0 1375.0 6321 **6321 0.3 1.2 6084 11.8 24.8

Média 5.4 390.4 0.1 0.2 5.1 18.3

107

leva muito menos tempo para encontrá-las e em sua execução completa. Destaca-se, também,

que este fornece mais dois certificados de otimalidade, nas instâncias CW2 e OF2. O

algoritmo RG2D obteve 23 soluções ótimas e esses resultados foram discutidos com ênfase no

Capítulo anterior.

As Tabelas 5.3-5.5 apresentam resultados nas 450 instâncias aleatórias mais recentes,

separadas por classe. Nestas tabelas, as colunas R_m_S e R_m_L correspondem às médias em

15 instâncias de um grupo. Também são fornecidas médias agregadas para 5 grupos com a

mesma classificação de item, indicada por S ou L. Em suas 5 primeiras linhas, são

apresentados os seguintes resultados do DP_AOG: limite superior, solução média de cada

grupo, tempo para encontrar a melhor solução e tempo total na sua execução, intervalo entre

limite superior e inferior, e porcentagem de instâncias onde a melhor solução foi certificada

por ser ótima. As próximas 5 linhas mostram estatísticas semelhantes as citadas para o X2D.

Nas 4 linhas restantes, as estatísticas sobre RG2D puro são: solução média em 10 execuções

por grupo, média das melhores soluções nas instâncias de cada grupo, tempo desta melhor

média e seu tempo total e intervalo em relação ao melhor limite superior conhecido.

TABELA 5.2 – Resultados nas Instâncias Clássicas sem Rotação e sem Peso.

Os resultados nas Tabelas 5.3-5.5 mostram que o algoritmo X2D diminui

substancialmente os intervalos entre os limites inferiores e superiores nos respectivos grupos.

Isto é observado nos 22 grupos que o X2D apresenta gaps menores em relação ao DP_AOG.

Instâncias AlgoritmosNome m DP_AOG Tempo ZUB X2D Tempo RG2D TempoWANG1 20 **2277 <0.1 0.1 2277 **2277 <0.1 <0.1 *2277 <0.1 7.1

WANG2 20 **2694 <0.1 0.2 2694 **2694 <0.1 <0.1 *2694 <0.1 6.7

WANG3 20 **2721 <0.1 0.6 2721 **2721 <0.1 <0.1 *2721 <0.1 7.0

OF1 10 **2737 0.1 11.2 2737 **2737 0.2 0.2 *2737 0.3 5.5

OF2 10 *2690 0.1 23.6 2690 **2690 0.3 0.3 *2690 <0.1 4.2

CU1 25 **12330 0.1 0.5 12330 **12330 <0.1 <0.1 *12330 <0.1 11.5

CU2 35 **26100 0.2 1.4 26100 **26100 <0.1 <0.1 *26100 0.1 14.7

CU3 45 **16723 0.3 5.8 16723 **16723 <0.1 <0.1 16679 17.4 24.8

CU4 45 **99495 3.8 35.0 99495 **99495 <0.1 0.1 *99495 10.0 17.2

CU5 50 **173364 2.7 873.2 173364 **173364 <0.1 0.1 173010 0.1 22.2

CU6 45 **158572 1.3 11.8 158572 **158572 <0.1 <0.1 *158572 <0.1 19.3

CU7 25 *247150 0.1 1800.0 247392 *247150 0.2 0.5 *247150 0.1 9.3

CU8 35 **433331 0.5 26.8 433331 **433331 <0.1 <0.1 *433331 9.1 14.0

CU9 25 **657055 0.1 19.7 657055 **657055 <0.1 <0.1 *657055 <0.1 13.2

CU10 40 *773772 69.2 1800.0 774954 *773772 2.2 53.6 772982 3.5 21.7

CU11 50 *924696 333.6 1293.1 925276 *924696 0.2 600.0 924311 14.6 24.7

Média 25.8 368.9 0.2 40.9 3.5 14.0

108

Nos demais grupos, em 6 ambos obtiveram gap zero e o DP_AOG foi melhor apenas nos

grupos R_40_S das classes 2 e 3. A diferença em termos de melhor solução, ou limite

inferior, é quase imperceptível na maioria desses grupos. Verifica-se que ambos os métodos

encontraram as mesmas soluções na classe 1. Nos 5 grupos de instâncias pequenas da classe

2, X2D foi melhor em 2 grupos e perdeu em 1 grupo. Já na classe 3, X2D continuou superior

em 3 desses grupos e DP_AOG foi melhor outros 2. Em geral, o X2D encontrou 307

certificados de otimidade contra 258 do DP_AOG e, mesmo tomando a diferença de

velocidade entre máquinas, X2D é consideravelmente mais rápido na maioria desses grupos.

Ainda sobre as Tabelas 5.3-5.5, o algoritmo RG2Da como uma heurística autônoma

não é competitivo com X2D e DP_AOG nos grupos de itens pequenos das Classes 1 e 2.

Entretanto, obtém resultados muito bons nas mais difíceis de todas as instâncias para os

métodos que utilizam PD, as da Classe 3. Nesta classe, RG2Da foi melhor do que DP_AOG em

3 grupos, empatou em 5 e perdeu em 2 destes. Ainda na classe 3, mesmo superando X2D em

apenas no grupo de itens pequenos R_50_S, é importante destacar que o sucesso do X2D

nestes grupos é atribuído as 31 melhores soluções geradas na fase 3 com a execução do

RG2Da. Em síntese, a qualidade das suas soluções também pode ser verificada nos 14 grupos,

cujos valores das suas melhores soluções não são superados pelo X2D, obtidas em tempo de

execução inferior a 7 segundos.

Os resultados do terceiro conjunto de instâncias, para o caso sem rotação, são

apresentados nas respectivas Tabelas 5.6 e 5.7. As colunas 3-5 são referentes ao algoritmo

A1, e mostram o valor do limite superior, da melhor solução e seu tempo de execução. De

forma análoga, têm-se as colunas 6-8 com as informações relativas à execução do X2D. Nas

colunas 9 e 10 encontram-se o valor da melhor solução e os tempos utilizados nas iterações do

RG2D em sua geração.

109

TABELA 5.3 – Resultados nas Instâncias Randômicas da Classe 1 sem Rotação e sem Peso.

Classe 1 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9838 9978 10000 10000 10000 9963.2 9129 9598 9838 9880 9898 9668.6DP_AOG10 9834 9976 10000 10000 10000 9962.0 9129 9595 9835 9861 9892 9662.4Tempo(s) 8.3 46.3 7.8 79.6 3.1 7.3 1.4 5.8 0.3 4.2 4.2 28.7 <0.1 0.8 1.1 6.7 <0.1 7.2 <0.1 12.8 <0.1 8.5 0.3 7.2

Gap(%) 0.04 0.02 0 0 0 0.01 0 0.03 0.03 0.19 0.06 0.06CO(%) 93.3 86.7 100 100 100 96.0 100 93.3 93.3 80.0 93.3 92.0ZUB 9835 9977 10000 10000 10000 9962.4 9129 9595 9835 9863 9892 9662.8X2D 9834 9976 10000 10000 10000 9962.0 9129 9595 9835 9861 9892 9662.4Tempo(s) <0.1 0.1 0.2 1.5 <0.1 <0.1 <0.1 <0.1 <0.1 0.3 <0.1 0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 0.1 <0.1 <0.1 <0.1 <0.1

Gap(%) 0.01 0.01 0 0 0 <0.01 0 0 0 0.02 0 <0.01CO(%) 93.3 93.3 100 100 100 97.3 100 100 100 93.3 100 98.7RG2DMed 9805.5 9945.0 9980.3 9990.3 9995.6 9943.3 9114.0 9579.3 9826.9 9855.1 9888.8 9652.8RG2D 9818 9958 9995 9998 10000 9953.8 9114 9582 9835 9861 9892 9656.8Tempo(s) 1.2 9.0 3.8 17.9 2.9 29.5 3.5 37.3 6.4 44.7 3.6 27.7 <0.1 3.4 0.1 7.8 0.6 13.0 0.9 16.7 0.4 20.9 0.4 12.4

Gap(%) 0.17 0.19 0.05 0.02 0 0.09 0.16 0.14 0 0.02 0 0.06

109

110

TABELA 5.4 – Resultados nas Instâncias Randômicas da Classe 2 sem Rotação e sem Peso.

Classe 2 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9829 9961 9998 10000 10000 9957.6 9253 9660 9842 9870 9904 9705.8DP_AOG10 9640 9909 9958 9996 10000 9900.6 9230 9635 9842 9867 9902 9695.2Tempo(s) 19.1 942.3 46.2 929.9 85.4 1206.4 48.3 350.6 26.1 31.6 45.0 692.2 <0.1 8.3 <0.1 19.8 <0.1 7.6 <0.1 12.6 <0.1 9.9 <0.1 11.6

Gap(%) 1.92 0.52 0.40 0.04 0 0.58 0.25 0.26 0 0.03 0.02 0.11CO(%) 6.7 6.7 6.7 66.7 100 37.4 86.7 60.0 93.3 86.7 93.3 84.0ZUB 9717 9935 9981 10000 10000 9926.6 9242 9635 9842 9867 9902 9697.6X2D 9644 9909 9960 9995 10000 9901.6 9230 9635 9842 9867 9902 9695.2Tempo(s) 7.5 89.7 0.5 74.3 6.8 92.8 36.7 60.0 8.6 8.6 12.0 65.1 <0.1 0.4 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 0.1

Gap(%) 0.75 0.26 0.21 0.05 0 0.25 0.13 0 0 0 0 0.03CO(%) 20.0 20.0 26.7 66.7 100 46.7 93.3 100 100 100 100 98.7RG2DMed 9592.9 9867.0 9911.6 9952.4 9968.7 9858.5 9230.3 9634.6 9841.5 9859.8 9901.6 9693.6RG2D 9608 9891 9939 9974 9984 9879.2 9230 9635 9842 9867 9902 9695.2Tempo(s) 1.3 6.1 1.6 9.5 3.1 13.7 6.5 19.6 5.0 24.0 3.5 14.6 <0.1 5.3 <0.1 10.8 <0.1 15.9 0.2 22.1 0.1 30.3 0.1 16.9

Gap(%) 1.12 0.44 0.42 0.26 0.16 0.48 0.13 0 0 0 0 0.03

110

111

TABELA 5.5 – Resultados nas Instâncias Randômicas da Classe 3 sem Rotação e sem Peso.

Classe 3 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9263 9923 9880 9890 10000 9791.2 8883 9469 9745 9832 9881 9562.0DP_AOG10 8115 9575 9671 9807 9770 9387.6 8746 9322 9685 9767 9823 9468.6Tempo(s) 0.7 752.2 89.5 532.6 194.7 638.6 425.7 670.6 1.73 1442.4 142.5 807.3 <0.1 11.9 <0.1 42.4 <0.1 47.0 <0.1 46.2 <0.1 59.2 <0.1 41.3

Gap(%) 12.39 3.51 2.12 0.84 2.30 4.23 1.54 1.55 0.62 0.66 0.59 0.99CO(%) 0 0 0 0 0 0 46.7 33.3 40.0 26.7 26.7 34.7ZUB 8910 9844 9952 9996 9998 9740.0 8769 9364 9708 9778 9842 9492.2X2D 8116 9544 9751 9865 9903 9435.8 8746 9322 9685 9767 9823 9468.6Tempo(s) 9.9 39.4 108.1 167.6 120.2 355.3 85.5 279.7 184.9 257.4 101.7 219.9 0.1 0.6 <0.1 1.5 0.1 3.6 0.1 2.0 0.2 5.3 0.1 2.6

Gap(%) 8.91 3.05 2.02 1.31 0.95 3.25 0.26 0.45 0.24 0.11 0.19 0.25CO(%) 6.7 0 0 0 0 1.3 86.7 73.3 53.3 80.0 40.0 66.7RG2DMed 8037.9 9511.4 9713.4 9840.8 9890.1 9398.7 8690.7 9321.3 9684.9 9765.7 9820.6 9456.6RG2D 8038 9522 9737 9864 9904 9413.0 8691 9322 9685 9767 9823 9457.6Tempo(s) <0.1 4.5 0.6 7.7 3.5 10.0 3.4 11.5 4.3 14.0 2.4 9.5 <0.1 2.6 <0.1 4.6 0.1 6.8 <0.1 9.8 0.2 12.1 0.1 7.2

Gap(%) 9.79 3.27 1.45 0.26 0.94 3.14 0.89 0.45 0.24 0.11 0.19 0.38

111

112

TABELA 5.6 – Resultados nas Instâncias APT sem Rotação e com Peso.

TABELA 5.7 – Resultados nas Instâncias APT sem Rotação e sem Peso.

Nesses testes, em função do tamanho das instâncias APT30-APT49, utilizou-se 3600

segundos como tempo limite de execução do algoritmo A1 e no X2D, TLim foi ampliado para

900 segundos. Além disso, é importante relatar que o algoritmo A1 usa limites inferiores e

superiores obtidos dos artigos de Hifi (2004b) e Chen (2008) como dados de entrada. Em

relação à parametrização do RG2Da não tem alterações.

A Tabela 5.6 mostra o desempenho dos algoritmos nas instâncias com peso APT40-

49. O algoritmo X2D aparece superior ao A1 e, consequentemente ao RG2D também, nas

instâncias APT42 e APT43. O X2D destaca-se pelo quantitativo de 8 soluções ótimas,

incluindo 3 certificados de otimalidade, com todas obtidas em excelente tempo

computacional. Já os resultados destes algoritmos nas instâncias sem peso APT30-APT39,

são apresentados na Tabela 5.7. Nesta tabela, é concludente a superioridade do algoritmo A1

perante a X2D e a RG2Da com as melhores soluções nas instâncias APT33 e APT35. Sendo os

Instâncias AlgoritmosNome m ZuB A1 Tempo ZUB X2D Tempo RG2D Tempo

APT40 56 67654 **67154 25.86 67154 **67154 1.04 23.41 65896 13.19 50.20

APT41 36 215699 **206542 229.30 206542 **206542 2.14 59.18 206302 1.19 27.89

APT42 59 34098 33503 3600.00 33680 33598 280.27 900.00 32770 3.39 52.47

APT43 49 222570 214651 3600.00 217288 214840 24.05 900.00 214471 16.92 41.27

APT44 39 74887 **73868 19.23 73868 **73868 93.54 194.20 72895 0.73 25.67

APT45 33 75888 **74691 19.73 74691 **74691 0.53 7.40 *74691 0.64 22.95

APT46 42 151813 **149911 37.00 149911 **149911 0.62 0.62 *149911 8.38 31.09

APT47 43 153747 **150234 51.80 150659 *150234 286.57 900.00 146892 29.20 33.16

APT48 34 170914 **167660 75.93 167835 *167660 144.38 900.00 167023 20.02 23.34

APT49 25 226346 **219354 2680.39 220383 *219354 254.31 900.00 214365 6.39 18.19

Média 1033.92 108.74 478.48 10.00 32.62

Instâncias AlgoritmosNome m ZuB A1 Tempo ZUB X2D Tempo RG2D Tempo

APT30 38 140904 **140904 2.43 140904 **140904 23.67 23.67 140461 7.62 30.64

APT31 51 824931 **823976 178.99 824483 *823976 150.24 900.00 821345 10.93 43.06

APT32 56 38068 **38068 0.37 38068 **38068 23.98 23.98 38011 29.89 41.16

APT33 44 236818 **236611 40.62 236678 236588 744.03 900.00 236024 3.36 33.22

APT34 27 362520 **361398 79.08 362219 *361398 176.17 900.00 360420 19.00 21.46

APT35 29 622644 **621021 15.36 622161 620948 18.89 900.00 619426 1.17 20.36

APT36 28 130744 **130744 18.06 130800 *130744 1.43 900.00 130276 21.43 24.91

APT37 43 387276 **387276 48.03 387276 **387276 24.27 277.31 385828 1.82 30.11

APT38 40 261698 **261395 44.63 261572 *261395 117.68 900.00 260622 2.77 29.95

APT39 33 268750 **268750 33.70 268926 *268750 602.00 900.00 268081 4.69 25.02

Média 46.13 188.24 662.50 10.27 29.99

113

limites primais estabelecidos através de algoritmos externos ao A1 com os tempos de geração

não contabilizados, torna-se difícil um parecer sobre a eficiência de A1 nestas instâncias.

Sobre o último conjunto de instâncias sem peso gcut1-gcut13, a Tabela 5.8 expõe

seus resultados em colunas equivalentes às tabelas anteriores. Objetivando confrontar os

resultados dos algoritmos propostos X2D e RG2Da, juntamente com o A1, nas instâncias de

demanda unitária pertencentes a este conjunto, estas confirmam como grande destaque o

RG2Da. Por exemplo, além do quantitativo de soluções ótimas ou iguais aos demais

algoritmos, a solução apresentada pela heurística GRASP na instância gcut13 é reconhecida

como a melhor da literatura para esta instância. Em relação ao X2D, este mantém o parâmetro

TLim = 600 segundos e não obtém limite inferior para gcut13 durante esse tempo. Nessas

instâncias, o algoritmo A1 utiliza uma heurística aleatorizada de múltiplas descidas baseada

no método First Fit Decreasing (FFD), rodada por 60 segundos, para obter o limite inferior

usado em sua entrada. Na gcut13, o tempo de execução dessa heurística é ampliado para 600

segundos. Já o limite superior de entrada é dado pelo menor valor entre os valores do padrão

ótimo não guilhotinado e do padrão ótimo irrestrito. Os tempos para obter esses limites

superiores não são reportados. Ainda sobre a execução do A1 nesse conjunto, informa-se que

seu limite de tempo foi 600 segundos nas instâncias gcut1-gcut12 e 3600 segundos na gcut13.

TABELA 5.8 – Resultados nas Instâncias gcut sem Rotação e sem Peso.

As tabelas restantes mostram resultados para a variante que permitem rotações de

itens. As Tabelas 5.9-5.10 correspondem às instâncias clássicas com e sem peso, 5.11-5.13 às

instâncias aleatórias mais recentes somente para o caso sem peso, 5.14-5.15 às instâncias de

Instâncias AlgoritmosNome m ZuB A1 Tempo ZUB X2D Tempo RG2D Tempo

gcut1 10 48368 **48368 2.89 48368 **48368 0.01 0.03 *48368 <0.01 2.23

gcut2 20 59798 **59307 5.56 59307 **59307 0.01 0.30 *59307 <0.01 4.36

gcut3 30 61275 **60241 6.50 60241 **60241 <0.01 0.01 *60241 0.28 6.33

gcut4 50 61380 **60942 12.95 61450 *60942 <0.01 18.55 *60942 <0.01 11.91

gcut5 10 195582 **195582 4.35 195582 **195582 0.10 0.73 193379 <0.01 2.26

gcut6 20 236305 **236305 7.13 236305 **236305 <0.01 0.01 *236305 <0.01 4.30

gcut7 30 240143 **238974 11.06 238974 **238974 0.01 0.03 *238974 <0.01 6.44

gcut8 50 245758 **245758 18.71 245758 **245758 0.01 0.03 *245758 <0.01 11.28

gcut9 10 939600 **919476 14.51 919476 **919476 0.05 0.35 *919476 <0.01 2.81

gcut10 20 937349 **903435 17.85 919796 *903435 <0.01 4.96 *903435 <0.01 3.88

gcut11 30 969709 **955389 29.65 960148 *955389 0.12 8.54 *955389 0.03 6.44

gcut12 50 979521 **970744 46.48 974394 *970744 <0.01 14.64 *970744 <0.01 11.44

gcut13 32 8736757 8532720 3600.00 8978489 – – 600.00 8618394 2.00 13.23

Média 290.59 0.02 49.86 0.18 6.69

114

grande porte para ambos os casos e 5.16 as instâncias com demandas unitárias e sem peso. O

formato dessas tabelas é semelhante às tabelas anteriores, exceto que não possuem os

resultados dos algoritmos DP_AOG e A1 para o PCBGR sem rotação. Vale ressaltar que não

há comparações dos algoritmos propostos neste trabalho com outro da literatura para o caso

rotacionado, porque não se conhece algum trabalho que abrangesse grande parte dessas

instâncias.

TABELA 5.9 – Resultados nas Instâncias Clássicas com Rotação e com Peso.

TABELA 5.10 – Resultados nas Instâncias Clássicas com Rotação e sem Peso.

Instâncias AlgoritmosNome m ZUB X2D Tempo RG2D TempoChW1 7 260 **260 <0.1 0.2 *260 <0.1 4.6

ChW2 10 2901 **2901 <0.1 1.0 2896 0.8 6.4

ChW3 20 1920 **1920 <0.1 0.5 *1920 0.4 12.8

CW1 25 6766 **6766 <0.1 0.2 6764 0.8 11.6

CW2 35 5689 **5689 <0.1 0.4 *5689 6.4 12.8

CW3 40 5744 **5744 0.1 8.2 *5744 0.8 17.9

CW4 39 7496 **7496 0.6 0.6 7466 10.2 17.8

CW5 35 11659 **11659 0.5 0.5 *11659 16.5 16.9

CW6 55 13203 **13203 0.4 20.1 12967 21.6 30.0

CW7 45 10880 **10880 <0.1 <0.1 *10880 0.3 21.9

CW8 60 4736 **4736 <0.1 0.1 *4736 8.6 37.1

CW9 50 11479 **11479 0.3 0.3 *11479 18.9 27.5

CW10 60 6835 **6835 1.6 1.6 *6835 21.2 31.3

CW11 60 6784 **6784 1.6 2.6 6520 20.1 25.5

Média 0.4 2.6 9.1 19.6

Instâncias AlgoritmosNome m ZUB X2D Tempo RG2D TempoWANG1 20 2277 **2277 <0.1 <0.1 *2277 <0.1 7.6

WANG2 20 2716 **2716 <0.1 <0.1 *2716 <0.1 8.4

WANG3 20 2771 **2771 <0.1 <0.1 *2771 0.1 8.4

OF1 10 2757 **2757 <0.1 0.2 2737 1.4 4.9

OF2 10 2769 **2769 <0.1 0.3 *2769 <0.1 4.9

CU1 25 12500 **12500 <0.1 <0.1 *12500 <0.1 12.8

CU2 35 26200 **26200 <0.1 <0.1 *26200 0.2 15.7

CU3 45 16750 **16750 <0.1 <0.1 16723 4.8 26.4

CU4 45 100230 **100230 <0.1 0.4 100158 2.2 18.4

CU5 50 174705 **174705 <0.1 0.1 *174705 <0.1 25.8

CU6 45 158572 **158572 <0.1 <0.1 *158572 0.3 20.8

CU7 25 255684 **255684 <0.1 <0.1 *255684 6.2 9.3

CU8 35 438383 **438383 <0.1 0.2 *438383 0.9 15.2

CU9 25 659648 **659648 <0.1 0.1 *659648 5.5 15.7

CU10 40 779239 **779239 0.1 0.1 777112 22.1 24.4

CU11 50 928215 928170 0.4 600.0 927133 4.6 28.3

Média <0.1 37.6 3.0 15.4

115 TABELA 5.11 – Resultados nas Instâncias Randômicas da Classe 1 com Rotação e sem Peso.

TABELA 5.12 – Resultados nas Instâncias Randômicas da Classe 2 com Rotação e sem Peso.

Classe 1 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9961 9999 10000 10000 10000 9992.0 9286 9776 9904 9929 9971 9773.2X2D 9961 9999 10000 10000 10000 9992.0 9286 9774 9904 9929 9971 9772.8Tempo(s) <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 <0.1 0.1 <0.1 <0.1 <0.1 0.1 <0.1 <0.1 <0.1 <0.1

Gap(%) 0 0 0 0 0 0 0 0,02 0 0 0 <0.01CO(%) 100 100 100 100 100 100 100 93.3 100 100 100 98.7RG2DMed 9908.5 9984.5 9995.0 9999.8 9999.6 9977.5 9285.1 9766.9 9902.1 9915.5 9963.0 9766.5RG2D 9925 9990 10000 10000 10000 9983.0 9286 9774 9903 9921 9969 9770.6Tempo(s) 1.7 10.9 1.6 19.8 2.8 33.6 1.4 42.4 0.5 54.5 1.6 32.2 <0.1 4.1 0.1 8.9 0.2 14.9 1.3 18.7 1.3 23.1 0.6 13.9

Gap(%) 0.36 0.09 0 0 0 0.09 0 0.02 0.01 0.08 0.02 0.03

Classe 2 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9887 9989 10000 10000 10000 9975.2 9546 9797 9909 9945 9966 9832.6X2D 9850 9976 10000 10000 10000 9965.4 9546 9797 9909 9945 9966 9832.6Tempo(s) 18.2 175.1 1.4 90.4 2.5 2.5 0.7 0.7 0.6 0.6 4.7 53.9 <0.1 <0.1 <0.1 <0.1 <0.1 0.1 <0.1 0.1 <0.1 <0.1 <0.1 <0.1

Gap(%) 0.37 0.13 0 0 0 0.10 0 0 0 0 0 0CO(%) 20.0 46.7 100 100 100 73.3 100 100 100 100 100 100RG2DMed 9795.8 9923.5 9962.9 9987.8 9996.8 9933.4 9546.3 9796.6 9908.5 9938.3 9964.8 9830.9RG2D 9817 9942 9974 9997 9999 9945.8 9546 9797 9909 9945 9966 9832.6Tempo(s) 1.0 6.9 3.3 11.6 6.6 16.9 3.1 20.2 2.2 26.6 3.2 16.4 <0.1 6.2 0.1 12.3 0.1 19.1 1.9 24.8 0.3 33.4 0.5 19.2

Gap(%) 0.71 0.47 0.26 0.03 0.01 0.30 0 0 0 0 0 0

115

116 TABELA 5.13 – Resultados nas Instâncias Randômicas da Classe 3 com Rotação e sem Peso.

Classe 3 R_10_S R_20_S R_30_S R_40_S R_50_S Média R_10_L R_20_L R_30_L R_40_L R_50_L MédiaZUB 9205 9950 10000 10000 10000 9831.0 9188 9624 9812 9910 9933 9693.4X2D 8413 9781 9887 9949 9967 9599.4 9183 9621 9803 9900 9927 9686.8Tempo 3.2 75.2 80.4 180.5 91.0 161.9 13.3 49.3 33.2 41.5 44.2 101.7 0.1 0.7 0.1 0.4 0.7 1.9 0.1 1.8 <0.1 1.7 0.2 1.3

Gap(%) 8.60 1.70 1.13 0.51 0.33 2.45 0.05 0.03 0.09 0.10 0.06 0.07CO(%) 0 0 0 6.7 13.3 4.0 93.3 93.3 80.0 60.0 73.3 80.0RG2DMed 8385.3 9762.6 9878.5 9933.5 9961.0 9584.2 9182.9 9621.1 9799.4 9895.8 9921.7 9684.2RG2D 8385 9773 9906 9953 9984 9600.2 9183 9621 9803 9896 9928 9686.2Tempo <0.1 5.0 1.8 7.9 3.7 10.8 6.3 12.0 8.0 14.1 4.0 10.0 <0.1 2.9 <0.1 5.0 0.5 7,7 0.3 10,2 1.2 12.7 0.4 7.7

Gap(%) 8.91 1.78 0.94 0.47 0.16 2.45 0.05 0.03 0.09 0.14 0.05 0.07

116

117

As Tabelas 5.9 e 5.10 mostram que X2D obtém certificados de otimalidade para 29

das 30 instâncias clássicas. Apenas a instância CU11 encontrou o limite superior de 928215

que difere do limite inferior 928170, com um gap muito pequeno de 0,005%. Os tempos para

gerar tais soluções também são pequenos. Verifica-se ainda que RG2D encontrou 20 dessas

soluções ótimas.

Comparando as Tabelas 5.11-5.13 com as Tabelas 5.3-5.5, entende-se que a variante

com rotação é melhor resolvida pelo X2D. As diferenças entre os limites superiores e

inferiores médios diminuem e o número total de certificados de otimalidade aumenta para

342. A maior diferença entre os algoritmos X2D e RG2Dar encontra-se nos grupos da classe 3.

Considerando a relação qualidade de solução versus tempo computacional na resolução, o

RG2Dar puro apresenta-se melhor do que o X2D nas instâncias com itens pequenos desta classe.

TABELA 5.14 – Resultados nas Instâncias APT com Rotação e com Peso.

TABELA 5.15 – Resultados nas Instâncias APT com Rotação e sem Peso.

Instâncias Algoritmos

Nome m ZUB X2D Tempo RG2D Tempo

APT40 56 67294 **67294 103.19 226.49 65961 8.69 47.19

APT41 36 211613 210713 140.04 900.00 210075 9.94 27.08

APT42 59 34010 33756 880.95 900.00 33073 35.13 59.38

APT43 49 219654 218820 727.45 900.00 214092 6.92 39.19

APT44 39 76306 76122 235.88 900.00 75127 14.16 27.67

APT45 33 74691 **74691 1.15 16.70 74691 1.01 23.36

APT46 42 150983 **150983 18.48 56.73 150680 24.73 37.83

APT47 43 152951 152778 89.38 900.00 149866 29.59 34.69

APT48 34 171896 170678 135.95 900.00 170039 0.81 23.66

APT49 25 224987 222248 727.90 900.00 219264 19.42 19.70

Média 306.04 659.99 15.04 33.97

Instâncias Algoritmos

Nome m ZUB X2D Tempo RG2D Tempo

APT30 38 140904 *140904 771.18 771.18 140461 8.19 33.64

APT31 51 825184 824878 723.32 900.00 823978 22.59 46.58

APT32 56 38068 *38068 424.94 458.79 38068 27.06 38.47

APT33 44 236903 *236903 0.39 0.39 236135 8.72 34.02

APT34 27 362520 361952 499.10 900.00 361292 1.53 20.69

APT35 29 622965 622518 144.88 900.00 619871 6.97 24.98

APT36 28 130988 130965 0.13 900.00 130628 0.08 21.69

APT37 43 387640 387439 19.54 900.00 387097 11.75 32.19

APT38 40 261698 261625 288.06 900.00 260943 2.16 32.38

APT39 33 269376 269278 38.16 900.00 269181 13.88 30.20

Média 290.97 753.04 10.29 31.48

118

Para analisar o comportamento dos algoritmos propostos neste trabalho em instâncias

maiores do PCBGR rotacionado com peso e sem peso, executam-se esses algoritmos nas

respectivas instâncias APT40-APT49 e APT30-APT39. De acordo com as Tabelas 5.14 e

5.15, o X2D obteve o total de 6 ótimos com certificação, no tempo limite de 900 segundos. Já

o RG2Dvr encontrou apenas 2 soluções ótimas nessas instâncias mas seus tempos médios são

bem razoáveis.

Na Tabela 5.16 estão os resultados das instâncias gcut para a variante do PCBGR

sem rotação e sem peso. Assim como no Capítulo 4, o RG2Dar destaca-se nesse tipo de

instância e, não somente reproduz todas as soluções encontradas pelo X2D, mas também

obtém uma solução de valor 8825746 na gcut13. Nesta instância, torna-se importante declarar

que o X2D utilizou todo o tempo de execução delimitado em 600 segundos no algoritmo X,

sem conseguir obter uma solução viável nos múltiplos padrões da PD relaxada e nas

viabilizações permitidas.

TABELA 5.16 – Resultados nas Instâncias gcut com Rotação e sem Peso.

A presente seção é concluída com uma análise detalhada dos resultados do X2D na

resolução do PCBGR sem rotação e com rotação. Como um total de 513 instâncias nos 4

conjuntos utilizados nos testes computacionais, as Tabelas 5.17 e 5.18 apresentam nas suas

colunas 2-4 os seguintes quantitativos discriminados por fases: soluções com certificado de

otimalidade (CO), melhores limites superiores (ZUB) e melhores soluções retornadas (ZB). Nas

colunas 5-8 são distinguidas quantas vezes essas melhores soluções foram encontradas

diretamente na solução ótima da PD relaxada (PD), pela viabilização desta solução ótima da

Instâncias AlgoritmosNome m ZUB X2D Tempo RG2D Tempo

gcut1 10 58136 **58136 0.01 0.01 *58136 <0.01 2.82

gcut2 20 60403 **60403 0.06 0.08 *60403 0.02 5.22

gcut3 30 60604 60485 0.03 2.30 60485 0.05 7.43

gcut4 50 61710 **61710 0.04 0.13 *61710 0.01 13.60

gcut5 10 233969 **233969 0.21 0.25 *233969 <0.01 2.78

gcut6 20 239393 **239393 0.01 0.02 *239393 <0.01 4.80

gcut7 30 245306 **245306 0.04 0.04 *245306 0.02 7.55

gcut8 50 247462 **247462 0.01 0.04 *247462 0.01 12.63

gcut9 10 933169 **933169 0.03 0.22 *933169 <0.01 3.10

gcut10 20 930896 922695 0.15 5.58 922695 0.01 4.62

gcut11 30 969151 **969151 0.01 11.98 *969151 0.01 7.72

gcut12 50 981660 980640 0.02 2.23 980640 0.46 12.60

gcut13 32 8997450 – – 600.00 8825746 3.08 15.83

Média 0.05 47.91 0.28 7.75

119

PD (Via. PD), encontrada nos subótimos da matriz desta PD (MPD) ou produzida a partir de

alguma viabilização nos múltiplos padrões desta matriz (Via. MPD).

Considerando todos os 1026 problemas resolvidos com ou sem rotação, é possível

concluir que a maioria dos 737 padrões de corte com certificação de ótimo é produzida pelo

algoritmo X. Ao aproveitar também seus múltiplos padrões, inclusive fazendo a viabilização,

aumenta-se consideravelmente a possibilidade de obter um limite inferior melhor ou até uma

solução com garantia de ótimo. A heurística X2H está sendo providencial para o resultado de

algumas poucas instâncias, mas consideradas importantes, como por exemplo, as clássicas

CU7 e CU10 do PCBGR sem rotação e sem peso. Ainda assim, a fase 4 do X2D carece de um

estudo mais minucioso que determine melhor os parâmetros utilizados na sua execução.

TABELA 5.17 – Limites Superiores e Inferiores por Fases do X2D para o PCBGR.

TABELA 5.18 – Limites Superiores e Inferiores por Fases do X2D para o PCBGR Rotacionado.

X2D CO ZUB ZB PD Viab. PD MPD Via. MPDFase 1 (X) 296 334 394 134 14 222 24Fase 2 (X2) 55 179 74 7 0 45 22Fase 3 (RG2D) - - 34 - - - -

Fase 4 (X2H) - - 10 1 0 8 1

X2D CO ZUB ZB PD Viab. PD MPD Via. MPDFase 1 (X) 326 379 413 149 14 209 41Fase 2 (X2) 60 134 61 13 0 30 18

Fase 3 (RG2D) - - 36 - - - -Fase 4 (X2H) - - 1 0 0 1 0

120

6 ALGORITMOS GERAÇÃO DE COLUNAS PARA O PCEBG

Os algoritmos GCH2D e GCH2Dr foram desenvolvidos por Velasco e Uchoa (2015)

para o PCEBG não estagiado, baseando-se na estratégia apresentada por Gilmore e Gomory

(1961), que além apresentar uma técnica de geração de colunas (GC), propuseram uma

abordagem residual que determina soluções inteiras aproximadas. Em geral, na GC, a solução

ótima para o PL Mestre (3.1) relaxado não é inteira. Admitindo que nesse vetor solução exista

pelo menos um padrão de corte com produção fracionada, consegue-se uma solução inteira

aproximada arredondando para baixo o número de repetições desse padrão. Restando assim,

uma instância residual denominada de Problema Residual, que geralmente apresenta uma

demanda consideravelmente menor que a do problema original. Sendo este Problema

Residual abordado como uma sequencia de PCBGR, são utilizados os algoritmos RG2Da e

RG2Dar na resolução dos respectivos casos sem e com rotação de itens. Outra questão

importante a ser considerada é que, diante da dificuldade de se resolver de forma exata o

subproblema (3.2) com padrões de corte restrito para o PCEBG não estagiado, utilizou-se uma

ideia apresentada por Cintra et al. (2008), que consiste em resolver este subproblema, gerando

padrões irrestritos e com peso atribuído aos itens, até para instâncias que admitem rotação dos

itens, por meio da técnica de Programação Dinâmica.

6.1 ALGORITMOS GCH2D e GCH2Dr

A versão original dos algoritmos GCH2D ou GCH2Dr inicia com o PL Mestre

contendo um conjunto de m+1 colunas, constituído de m padrões homogêneos, com os itens

copiados em sua quantidade máxima em cada objeto, e adicionado de um padrão gerado, com

o valor de utilidade dos itens igual as respectivas medidas de área, pelo algoritmo DP

apresentado no Capítulo 5. A cada iteração seguinte, se for vantajoso, atribui-se aos itens os

valores das suas respectivas variáveis duais, gera e insere uma nova coluna ao PL Mestre.

Caso a solução ótima desse PL Mestre não seja inteira, a instância residual é extraída por

arredondamento para o maior inteiro menor ou igual à solução relaxada corrente e, os

algoritmos RG2Da ou RG2Dar, solucionam o problema residual com padrões de corte restritos,

compondo assim a solução inteira do PCEBG original. Na etapa em que se resolve o

Problema Residual, é interessante ressaltar que fica estabelecido como critério de parada nos

algoritmos RG2D atender toda demanda remanescente.

121

Na seguinte descrição do pseudocódigo geral, para os dois algoritmos enfatizados na

subseção presente, primeiramente, considera-se a definição das variáveis ainda não declaradas

para os respectivos processos.

� S*PCEBG : solução do PCEBG;

� valorS*PCEBG : número total de objetos na solução do PCEBG;

� S*

Rel : solução relaxada do PL Mestre;

� SApr : solução inteira aproximada do PL Mestre;

� valorSApr : número de objetos na solução inteira aproximada;

� itensPR : número total de itens na instância residual.

Algoritmo GCH2D (Α,Ψ, iterC, iterR) 1. S

*PCEBG = ∅ e valorS

*PCEBG = 0;

2. Determine as colunas [y1,..., ym]t de padrões homogêneos para o PL Mestre; 3. Gere nova coluna para o PL Mestre executando DP, com v(pi) = ci.li; 4. Resolva o PL Mestre; 5. Obtenha as variáveis duais πi; 6. Gere uma coluna y para o PL Mestre executando DP, com v(pi) = πi;

7. Se (=1

1 - yπ∑m

i i

i

< 0) então

8. Adicione a nova coluna o PL Mestre e volte ao passo 4; 9. Arredonde para baixo S*

Rel para obter a solução inteira aproximada, SApr e valorSApr; 10. Determine os dados da instância residual, pj` e dj` e itensPR; 11. Atualize S*

PCEBG = SApr e valorS*PCEBG = valorSApr;

12. Enquanto (itensPR > 0) faça 13. Resolva o problema residual executando RG2D (Α,Ψ, iterC, iterR); 14. Atualize S*

PCEBG = S*PCEBG U padcorteS

* e valorS*PCEBG = valorS

*PCEBG + 1;

15. Atualize os dados da instância residual, pj` e dj`; 16. Se (dj` = 0) então 17. Atualize número de itens, itensPR = itensPR - 1; 18. Retorna (S*

PCEBG, valorS*PCEBG);

Fim GCH2D

É importante observar que Cintra et al. (2008) também propuseram quatro

algoritmos baseados na GC para o PCEBG, sem restrições de estágios de corte, chamados de

CG, CGP, CGR e CGRP, distinguindo os dois últimos pela possibilidade de rotação ortogonal

dos itens. O algoritmo CG tenta resolver os problemas residuais recursivamente, fazendo uma

nova geração de colunas e um novo arredondamento. Esse processo para quando todas as

variáveis na solução ótima do PL mestre relaxado tem valor menor que 1, fazendo com que

seu arredondamento para baixo dê zero. Neste momento, o problema residual é resolvido

pelo algoritmo Modified Hybrid First Fit (M-HFF), que consiste numa ampliação do HFF

para o caso restrito. O M-HFF é um algoritmo aproximativo com garantia 2,077, como

provado por Caprara (2002). O algoritmo CGP usa uma estratégia diferente quando o

122

arredondamento da solução do PL ótimo dá zero. Ao invés de resolver todo o problema

residual com o M-HFF, esse algoritmo é usado para gerar apenas um padrão de corte, que é

subtraído da demanda residual. Essa nova solução residual “perturbada” é resolvida

recursivamente, voltando-se a GC. Os algoritmos CGR e CGRP são versões adaptadas dos

algoritmos CG e CGR, devido à rotação dos itens, onde o algoritmo First Fit Decreasing

Height using Rotations (FFDHR) substitui o algoritmo M-HFF.

6.3 RESULTADOS COMPUTACIONAIS

Os algoritmos propostos para o PCEBG foram implementados em linguagem C/C++,

as relaxações do PL Mestre foram resolvidas pelo CPLEX Optimization Studio 12.5.1 e os

testes foram realizados em um computador com processador Intel(R) Core(TM)i5-3320M

2.60 GHz, com 4GB de memória RAM e sistema operacional Windows 7 de 64 bits.

A seguir, são apresentados os testes computacionais com os algoritmos GCH2D e

GCH2Dr para o PCEBG não estagiado, sem e com rotação, respectivamente. Esses testes, para

comparar os resultados obtidos com os algoritmos CG, CGP, CGR e CGRP, foram divididos

em dois grupos de 12 instâncias, contendo as mesmas informações, que se diferenciam por

permitir ou não a rotação ortogonal dos itens. Originalmente, essas instâncias foram propostas

por Beasley (1985), com o total de itens distintos iguais a 10, 20, 30 e 50, a serem cortados

em objetos de dimensões (250, 250), (500, 500) e (1000, 1000). Estas são referenciadas em

diversos trabalhos que abordam a geração de padrões para o PCBGI e estão disponibilizadas

em OR-Library1. Como estas instâncias eram para o caso irrestrito, Cintra et al. (2008)

providenciou demandas geradas aleatoriamente2 e as renomeou de gcut1d,...,gcut12d e

gcut1dr,...,gcut12dr, respectivamente. Os referidos autores implementaram seus algoritmos

em linguagem C e executaram os testes em um computador com processador Intel Pentium IV

1.8 GHz, com 512 Mb de memória RAM, sistema operacional Linux e resolvedor CLP

(COIN-OR LP Solver). No benchmark de endereço www.cpubenchmark.net, a informação é

que os testes executados neste processador são 3.8 vezes mais lentos, quando a comparação é

feita com o processador utilizado nas rodadas dos algoritmos GCH2D e GCH2Dr.

Nas rodadas dos algoritmos RG2Da e RG2Dar, o critério de parada ficou estabelecido

em atender a demanda do problema residual. Em todas as execuções, foi adotado valor 0 para

o parâmetro ψ e parâmetros φ e δ estavam fixados em 1. Na variação do parâmetro α, este

parâmetro assume os valores de A, que iniciam com 0.1 e é incrementada de 0.1 até o valor 1.

1 http://people.brunel.ac.uk/~mastjjb/jeb/info.html 2 http://www.ime.usp.br/~glauber/gcut/instances/

123

Dessa maneira, fazendo iterC = 10 e iterR = 0 adotando-se 1 iteração para cada valor α em A e

utilizando pitens = 10%, o melhor padrão gerado é escolhido para compor a solução e a

demanda atualizada. Com esta configuração definida, estes algoritmos são equivalentes aos

respectivos algoritmos G2Da/ar, executando apenas a fase de diversificação com ψ = 0.

As tabelas 6.1 e 6.2 apresentam os resultados obtidos em 10 execuções com os

algoritmos GCH2D e GCH2Dr. As seis primeiras colunas correspondem ao nome da instância,

número de itens distintos, dimensões do objeto, número de colunas geradas pela PD, limite

inferior obtido pela GC, valor da solução aproximada obtida por arredondamento da solução

fracionária. As quatro colunas seguintes se referem à melhor das 10 rodadas, à solução do

problema residual, ao tempo gasto com no residual (Tg), ao valor da solução final do PCE

obtida e o tempo total da rodada, incluindo a GC (T). As duas colunas seguintes são o valor

médio da solução final obtida em cada uma das rodadas e o tempo médio de uma rodada. As

colunas restantes, com valores retirados de Cintra et al. (2008), mostram as melhores soluções

e o tempo gasto pelos algoritmos daqueles autores. Como os algoritmos CG e CGp tiveram

resultados muito similares na Tabela 6.1 eles são mostrados como um único algoritmo. É

importante observar nessas tabelas os valores de soluções marcados com *, pois indicam as

soluções melhoradas obtidas pelos novos algoritmos e os tempos são apresentados em

segundos.

Das instâncias utilizadas no PCEBG sem rotação, verifica-se na tabela 6.1 que o

algoritmo GCH2D encontrou 11 soluções ótimas, ou seja, com o número de padrões de corte

produzidos igual ao limite inferior arredondado para cima. Estes resultados quando

comparados com o desempenho dos algoritmos CG e CGP, que obtiveram a mesma solução

nessas instâncias, evidenciam a eficiência do GCH2D com 8 soluções melhores.

Na tabela 6.2, os resultados para o grupo de instâncias cabíveis de rotação,

demonstram que o algoritmo GCH2Dr também foi eficiente, superando em 9 e 8 instâncias os

algoritmos CGR e CGRP, respectivamente. Ainda nessa tabela 2, é possível conferir que o

algoritmo proposto obteve 12 soluções ótimas com a configuração adotada. Deve-se observar

que em nenhuma instância dos dois grupos, os algoritmos propostos apresentaram resultados

inferiores CG, CGP, CGR e CGRP e que os tempos computacionais dos algoritmos são

confrontáveis, comprovando não só a eficácia, mas também a competitividade, desses

algoritmos. Vale ressaltar, também, que depois de exaustivos testes, aumentando

consideravelmente o número de iterações no algoritmo RG2Da, não foi possível encontrar uma

solução de valor igual ao limite inferior de 690 para a instância gcut8d.

124

TABELA 6.1 – Resultados do GCH2D com Padrões de Corte Residuais RG2Da.

TABELA 6.2 – Resultados do GCH2Dr com Padrões de Corte Residuais RG2Dar.

Instância m.Dimensões

ObjetoColunas Geradas

Limite Inferior

Solução Aprox.

Solução RG2D

TgSolução

GCH2DT

Solução GCH2Dm

TmSolução CG/CGp

TcSolução

CGRpTp(s)

gcut1d 10 (250, 250) 21 293.25 2920 2000 <0.01 *294 <0.01 *294.0 0.01 *294 0.03gcut2d 20 (250, 250) 35 344.25 3430 2000 <0.01 *345 <0.01 *345.0 0.01 *345 0.28gcut3d 30 (250, 250) 75 331.50 3200 12000 <0.01 *332 <0.03 *332.8 0.04 *333 0.77gcut4d 50 (250, 250) 93 835.83 8230 13000 <0.02 *836 <0.08 *836.9 0.07 *837 5.09gcut5d 10 (500, 500) 22 196.83 1940 3000 <0.01 *197 <0.01 *197.6 0.01 *198 0.03gcut6d 20 (500, 500) 43 342.67 3380 5000 <0.01 *343 <0.01 *343.5 0.01 *344 0.21gcut7d 30 (500, 500) 53 591.00 5850 6000 <0.01 *591 <0.01 *591.9 0.01 *592 0.33gcut8d 50 (500, 500) 133 690.00 6750 16000 <0.02 *691 <0.08 *691.5 0.10 *692 3.60gcut9d 10 (1000, 1000) 24 130.67 1260 5000 <0.01 *131 <0.01 *131.2 0.01 *132 0.06

gcut10d 20 (1000, 1000) 33 293.00 2900 3000 <0.01 *293 <0.01 *293.0 0.01 *293 0.09gcut11d 30 (1000, 1000) 74 329.38 3180 12000 <0.01 *330 <0.04 *330.7 0.04 *331 1.07gcut12d 50 (1000, 1000) 114 671.50 6620 10000 <0.01 *672 <0.06 *672.2 0.07 *672 3.35

Instância m.Dimensões

ObjetoColunas Geradas

Limite Inferior

Solução Aprox.

Solução RG2D

TgSolução

GCH2DT

Solução GCH2Dm

TmSolução

CGRTc

Solução CGRp

Tp

gcut1dr 10 (250, 250) 14 290.25 2860 5000 <0.01 *291 <0.01 *291.0 0.01 *291 0.04 *291 0.06gcut2dr 20 (250, 250) 42 281.88 2760 6000 <0.01 *282 <0.03 *282.4 0.04 *283 1.41 *283 1.57gcut3dr 30 (250, 250) 125 312.57 3000 13000 <0.01 *313 <0.09 *313.9 0.09 *315 1.89 *314 3.38gcut4dr 50 (250, 250) 91 835.50 8230 13000 <0.01 *836 <0.05 *836.1 0.07 *836 4.40 *836 6.82gcut5dr 10 (500, 500) 25 173.96 1690 5000 <0.01 *174 <0.01 *174.9 0.01 *175 0.06 *175 0.10gcut6dr 20 (500, 500) 51 300.50 2940 7000 <0.01 *301 <0.02 *301.2 0.02 *302 0.25 *302 0.28gcut7dr 30 (500, 500) 61 542.00 5390 3000 <0.01 *542 <0.02 *542.8 0.02 *544 0.99 *543 1.18gcut8dr 50 (500, 500) 152 649.23 6360 14000 <0.01 *650 <0.23 *650.8 0.25 *651 6.47 *651 7.10gcut9dr 10 (1000, 1000) 26 121.92 1190 3000 <0.01 *122 <0.02 *122.9 0.01 *123 0.07 *123 0.10

gcut10dr 20 (1000, 1000) 44 269.50 2680 2000 <0.01 *270 <0.01 *270.0 0.02 *270 0.21 *270 0.26gcut11dr 30 (1000, 1000) 97 297.39 2870 11000 <0.01 *298 <0.30 *298.7 0.29 *299 6.00 *299 6.47gcut12dr 50 (1000, 1000) 143 601.00 5910 10000 <0.01 *601 <0.28 *602.1 0.34 *602 19.24 *601 19.57

125

7 CONCLUSÕES E TRABALHOS FUTUROS

Neste trabalho foram realizados estudos sobre dois problemas clássicos, que são o

PCBGR e o PCEBG, com o intuito de apresentar métodos eficientes para resolução desses

problemas. São propostos os algoritmos RG2D e X2D para tratar o PCBGR, nas variantes que

combinam a forma como se define o valor de utilidade dos itens e a questão de permitir ou

não a rotação desses itens. Para as variantes sem e com rotação do PCEBG, propõe-se

resolvê-las com as respectivas versões dos algoritmos GCH2D.

Primeiramente no Capítulo 4, foram expostos os fundamentos necessários para

construção dos algoritmos RG2Da/v/ar/vr, concebidos a partir de ampliações no algoritmo G2D

original, para resolução do PCBGR nas variantes que consideram a forma como se define o

valor de utilidade dos itens e a questão de permitir ou não a rotação desses itens. As seguintes

contribuições foram apresentadas neste Capítulo, sobre o PCBGR:

■ O algoritmo G2D, baseado na metodologia de GRASP para determinação de faixas

guilhotinas e inicialmente criado em Velasco (2005) foi modernizado para o PCBGR, com

os princípios do GRASP Reativo e a criação de novos parâmetros que consideram: a

repetição de faixas guilhotinas homogêneas; o quantitativo de itens utilizados na geração

do padrão de corte; novos movimentos de melhoria que possibilitam, inclusive, a

recuperação de perdas internas em uma faixa, denominadas dentes; na composição do

padrão de corte que as faixas apresentam um percentual aceitável de perda interna. Nos

algoritmos propostos RG2D, os parâmetros principais α e ψ responsáveis pela cardinalidade

dos conjuntos LRC e LRF, são calibráveis ainda na fase de diversificação a partir de

valores pré-estabelecidos para determinação dos parâmetros reativos αR e ψR a serem

utilizados na fase reativa seguinte.

Com estratégias que diferem de acordo com o valor de utilidade dos itens, os

algoritmos RG2Da/v/ar/vr foram analisados separadamente em dois grupos de instâncias e os seus

resultados foram comparados aos valores das soluções de algoritmos competitivos e bastante

conhecidos na literatura. Os resultados para o caso sem rotação foram promissores quando

comparados aos algoritmos GRASP, GR/PR e TS500 (ALVAREZ-VALDÉS et al., 2002a),

conseguindo uma quantidade significativa soluções ótimas, nas 50 instâncias analisadas, e as

demais apresentando um gap pequeno com tempos computacionais de execução procedentes

em média inferiores a 60 segundos. Nas instâncias gcut1-gcut13, esta comparação se fez com

o algoritmo exato A1 e vale ressaltar que a versão reativa RG2Da encontrou a melhor solução

conhecida para a instância em aberto gcut13. Como não se conhece trabalhos na literatura que

126

abordem esses conjuntos de instâncias para variante com rotação, os resultados gerados com

as versões do RG2D são apenas apresentados com seus gaps calculados a partir dos limites

superiores do algoritmo X2D proposto no Capítulo 5.

O Capítulo 5 iniciou destacando as dificuldades encontradas na resolução do PCBGR

via PD, com a inclusão de m dimensões às fórmulas de recorrência, que justificaram a

proposta feita por Christofides e Hadjiconstantinou (1995) de relaxação de espaço de estados

adicionando apenas uma dimensão. Em sequência, são apresentados os algoritmos duais X e

X2, que utilizam PI na determinação do vetor de pesos q da PD relaxada, para obter limites

superiores fortes para o PCBGR. Em relação aos limites inferiores, estes podem ser obtidos

com os algoritmos primais RG2D e X2H, nos múltiplos padrões subótimos da PD ou através

de uma heurística de viabilização aplicada nos padrões inviáveis gerados por X, X2 e X2H.

As contribuições apresentadas no Capítulo 5 da tese, ainda sobre o PCBGR, são:

■ É proposto o algoritmo X, baseado em PI, para a obtenção dos pesos ótimos para a

relaxação de espaço de estados proposta por Christofides e Hadjiconstantinou (1995) para

o PCBGR. Esses pesos são ótimos no sentido de levar ao menor limite superior para o

PCBGR possível de ser obtido com essa relaxação e ainda obter esse limite com o menor

fator de aumento da complexidade da PD possível. Também foi provado que, caso o

algoritmo X seja truncado pelo máximo valor de Q aceitável, o algoritmo determina os

melhores pesos possíveis com essa limitação.

■ Apresenta-se o algoritmo X2 que aplica técnicas similares sobre uma generalização da

relaxação de espaço de estados que usa pesos bidimensionais. O algoritmo X2 utiliza

programação inteira com função objetivo quadrática e possui propriedades teóricas

similares ao algoritmo X, obtendo pesos bidimensionais ótimos. A versão que usa função

objetivo aproximada por uma linearização também acha o melhor limite superior possível.

Entretanto, isso pode não ocorrer com o menor fator de aumento da complexidade da PD.

■ O algoritmo X2H é uma adaptação do algoritmo X2 para transformá-lo em uma heurística

primal e, assim, buscar soluções viáveis que melhore o limite ZLB.

■ É produzido o algoritmo X2D, combinando os algoritmos X, X2, X2H com a heurística

RG2D. O algoritmo X2D também busca por soluções primais utilizando tanto as soluções

ótimas quanto as soluções subótimas encontradas nas matrizes dos algoritmos baseados em

PD. Caso essas soluções sejam quase viáveis, no sentido de apresentarem um número

muito pequeno de itens produzidos em excesso, é utilizado um procedimento de

viabilização.

127

Para o caso não rotacionado, é possível fazer comparações diretas com o algoritmo

DP_AOG, que consiste no híbrido de programação dinâmica com relaxação de espaço de

estados e uma heurística primal baseada na abordagem grafo E/OU, e apresenta os melhores

resultados para um algoritmo primal-dual na literatura. O algoritmo X2D representa

claramente uma evolução sobre o algoritmo DP_AOG. Na grande maioria das instâncias ou

os gaps de dualidade obtidos são menores ou os tempos de execução são reduzidos.

Comparações com o algoritmo A1, o melhor algoritmo exato da literatura, são possíveis em

um número mais restrito de 33 instâncias. O algoritmo A1, que usa limites inferiores e

superiores externos como dados de entrada, é capaz de resolver 30 dessas instâncias de forma

ótima. Entretanto, pela sua natureza enumerativa exponencial, o algoritmo A1 falha

completamente nessas 3 instâncias, estourando o seu tempo limite de execução sem melhorar

em nada os limites externos recebidos. Algoritmos como o X2D ou DP_AOG, por serem

baseados em componentes com complexidade no máximo pseudo-polinomial, são mais

robustos. De fato, X2D encontrou as melhores soluções conhecidas para duas dessas instâncias

em aberto, APT42 e APT43. Com a parametrização adotada, o algoritmo X2D obteve 16

certificados de otimalidade e gaps pequenos nas 30 instâncias que puderam ser resolvidas por

A1, gastando em geral um tempo significativamente menor.

No caso rotacionado, ainda não havia resultados disponíveis na literatura para

comparação com o algoritmo X2D. Acreditamos que os resultados publicados nesta tese

certamente serão utilizados por outros pesquisadores no futuro que desejem explorar essa

variante do PCBGR. De qualquer forma, os resultados mostraram que o algoritmo X2D

apresenta desempenho ainda melhor quando as rotações são permitidas, encontrando mais

soluções certificadas de serem ótimas e obtendo menores gaps de dualidade médios.

O Capítulo 6 tem como objeto de estudo o PCEBG e foram apresentados os

algoritmos híbridos GCH2D e GCH2Dr, que originalmente combinam a técnica de GC com o

algoritmo DP e a metaheurística GRASP, utilizando os algoritmos RG2D e para resolver os

respectivos Problemas Residuais dos casos sem e com rotação. As contribuições originais do

Capítulo 6 são:

■ Com as ampliações que resultaram nos algoritmos RG2D, estes se tornaram mais rápidos e

flexíveis, permitindo seu uso em várias etapas dos novos algoritmos híbridos da GC

proposta para o PCEBG. Os algoritmos GCH2D seguem a ideia geral de arredondar a

solução fracionária da GC para uma solução inteira e resolver o Problema Residual,

definido pelos itens com demanda ainda não totalmente atendida, utilizando

128

sistematicamente os algoritmos RG2D na produção de padrões constituídos desses itens

remanescentes.

Em instâncias propostas por Beasley (1985) e adaptadas por Cintra et al. (2008), os

resultados foram bastante satisfatórios, apresentando soluções melhores do que as obtidas por

Cintra et al. (2008) em 16 das 24 instâncias e empatando nas demais. É importante ressaltar

que foram obtidas 23 soluções provadamente ótimas em tempos computacionais muito

reduzidos. Além disso, a solução apresentada na instância gcut8d possui 1 unidade a mais do

limite inferior dado pela GC. Esse resultado indica que o limite da GC para o PCEBG, mesmo

quando os subproblemas são definidos como PCBGI, é bastante forte na prática. Isto é, esses

resultados suportariam uma Conjectura MIRUP para o PCEBG.

Como perspectivas para trabalhos futuros são indicadas nas seguintes propostas:

■ Identificar uma melhor calibragem dos parâmetros envolvidos nos algoritmos propostos

para o PCBGR e o PCEBG;

■ Combinar a utilização de técnicas exatas ou outras heurísticas nas novas ampliações do

algoritmo G2D;

■ Implementar um algoritmo de busca em árvore que realize uma enumeração completa no

espaço de estados relaxado da PD, baseado no algoritmo proposto por Christofides e

Hadjiconstantinou (1995) para resolver de forma exata o PCBGR;

■ Considerar estratégias diferentes para tratar o subproblema e o problema residual

provenientes da GC híbrida proposta para o PCEBG;

■ Ampliar os algoritmos propostos para que possam ser aplicados a outras variantes dos

Problemas de Corte e Empacotamento, como por exemplo, o Problema de Empacotamento

Bidimensional em Faixas, o Problema de Corte de Estoque com aproveitamento de sobras

do objeto e o qual utiliza objetos retangulares de diferentes tamanhos.

129

REFERÊNCIAS BIBLIOGRÁFICAS

ALVARENGA, A.G.; DAZA, V.P. Um método de busca informada para o problema do corte de peças. Anais do IX Congresso Brasileiro de Automática, Vitória, 1992.

ALVARENGA, A.G.; GOMES, F.N.; PARADA, V. O problema de corte de peças na indústria de calçados. Anais do VII Congresso Latino-Ibero-Americano de Investigação

Operativa. Santiago, 1994.

AMARAL, A. R. S. Abordagens via Tabu Search e Simulated Annealing para o Problema de

Corte Bi-dimensional Restrito. 1994. Dissertação (Mestrado em Engenharia Elétrica – Automação) – Programa de Pós-Graduação em Engenharia Elétrica, UFES, Vitória.

AMARAL, A.R.S.; WRIGHT, M, Efficient algorithm for the constrained two-dimensional cutting stock problem, International Transactions in Operational Research, v.8, p.3-13, 2001.

BEASLEY, J. E. Algorithms for unconstrained two-dimensional guillotine cutting. Journal of

the Operational Research Society, p. 297-306, 1985.

CAPRARA, A. Packing 2-dimensional bins in harmony. In: Foundations of Computer

Science, 2002. Proceedings. The 43rd Annual IEEE Symposium on. IEEE, p. 490-499, 2002.

CHEN, Y. A recursive algorithm for constrained two-dimensional cutting problems. Computational Optimization and Applications, v. 41, n. 3, p. 337, 2008.

CHRISTOFIDES, N.; WHITLOCK, C. An algorithm for two-dimensional cutting problems. Operations Research, n. 25, p. 30-44, 1977.

CHRISTOFIDES, N.; HADJICONSTANTINOU, E. An exact algorithm for orthogonal 2-D cutting problems using guillotine cuts. European Journal of Operational Research, n. 83, p. 21-38, 1995.

CINTRA, G. F.; MIYAZAWA, F. K.; WAKABAYASHI, Y.; XAVIER, E. C. Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation. European Journal of Operational Research, 191(1), 61-85, 2008.

CUI, Y. Simple block patterns for the two-dimensional cutting problem. Mathematical and

computer modelling, v. 45, n. 7, p. 943-953, 2007.

CUNG, V.D.; HIFI, M.; LE CUN, B. Constrained two-dimensional cutting stock problems. A best-first branch-and-bound algorithm. International Transactions in Operational Research, n. 7, p. 185-210, 2000.

DANTZIG, G.B.; WOLFE, P. Decomposition principle for linear programs. Operations

Research, v. 8, n. 1, p. 101-111, 1960.

DAZA, V.P.; ALVARENGA, A.G.; DIEGO, J. Exact solutions for constrained two-dimensional cutting problems. European Journal of Operational Research, n. 84, p. 633-644, 1995.

DOLATABADI, M.; LODI, A.; MONACI, M. Exact algorithms for the two-dimensional guillotine knapsack. Computers & Operations Research, v. 39, n. 1, p. 48-53, 2012.

130

DYCKHOFF, H. A new linear programming approach to the cutting stock problem. Operations Research, v. 29, n. 6, p. 1092-1104, 1981.

DYCKHOFF, H. A typology of cutting and packing problems. European Journal of Operational Research, n. 44, p. 145-149, 1990.

DYCKHOFF, H.; FINKE, U. Cutting and Packing in Production and Distribution: Typology

and Bibliography. Heidelberg: Springer-Verlag Co., 1992.

ESICUP. Euro Special Interest Group on Cutting and Packing. Disponível em: <http://paginas.fe.up.pt/~esicup/> (último acesso 21/02/2015).

FAYARD, D.; HIFI, M.; ZISSIMOPOULOS, V. An efficient approach for large-scale two-dimensional guillotine cutting stock problems. Journal of the Operational Research Society, v.49, p.1270-1277, 1998.

FEO, T.A.; RESENDE, M.G.C. A probabilistic heuristic for a computationally difficult set covering problem. Operation Research Letters, n. 8, p. 67-71, 1989.

FEO, T.A.; RESENDE, M.G.C. Greedy Randomized Adaptive Search Procedures. Journal of

Global Optimization, n. 6, p. 109-133, 1995.

FURINI, F.; MALAGUTI, E.; DURÁN, R. M.; PERSIANI, A.; TOTH, P. A column generation heuristic for the two-dimensional two-staged guillotine cutting stock problem with multiple stock size. European Journal of Operational Research, 218(1), 251-260, 2012.

FURINI, F.; MALAGUTI, E.; THOMOPULOS, D. Modeling two-dimensional guillotine cutting problems via integer programming. INFORMS Journal on Computing, v. 28, n. 4, p. 736-751, 2016.

GAREY M. R.; JOHSON D. S. Computers and Intractability: a guide to the theory of NP-

Completeness. New York: W. H. Freeman and Company, 1979.

GILMORE, P.C.; GOMORY, R.E. A linear programming approach to the cutting stock problem. Operations Research, n. 9, p. 849-859, 1961.

GILMORE, P.C.; GOMORY, R.E. A linear programming approach to the cutting stock problem - Part II. Operations Research, n. 11, p. 863-888, 1963.

GILMORE, P.C.; GOMORY, R.E. Multistage cutting stock problems of two and more dimensions. Operations Research, n. 13, p. 94-120, 1965.

GILMORE, P.C.; GOMORY, R.E. The theory and computation of knapsack functions. Operations Research, n. 14, p. 1045-1074, 1966.

HERZ, J.C. Recursive computational procedures for two-dimensional stock cutting. IBM

Journal of Research and Development, n.16, p. 462-469, 1972.

HIFI, M. An improvement of Viswanathan and Bagchi's exact algorithm for cutting stock problems. Computers & Operations Research, n.24, p. 727-736, 1997.

HIFI, M. Dynamic programming and hill-climbing techniques for constrained two-dimensional cutting stock problems. Journal of Combinatorial Optimization 8, 65-84, 2004.

131

LODI, A.; MONACI, M. Integer linear programming models for 2-staged two-dimensional knapsack problems. Mathematical Programming, v. 94, n. 2-3, p. 257-278, 2003.

MARCOTTE, O. An instance of the cutting stock problem for which the rounding property does not hold. Operations Research Letters, v. 4, n. 5, p. 239-243, 1986.

MORABITO, R.; ARENALES, M. N.; ARCARO, V. F. An and–or-graph representation to generate cutting patterns for the two-dimensional cutting problem. Workshop on

Combinatorial Optimization. Rio de Janeiro, 1989.

MORABITO, R.; ARENALES, M. N.; ARCARO, V. F. An and–or-graph approach for two-dimensional cutting problems. European Journal of Operational Research, n. 58, p. 263-271, 1992.

MORABITO, R.; ARENALES, M. N. Staged and constrained two-dimensional guillotine cutting problems: an AND/OR-graph approach. European Journal of Operational Research, n. 94, p. 548-560, 1996.

MORABITO, R.; PUREZA, V. A heuristic approach based on dynamic programming and and/or-graph search for the constrained two-dimensional guillotine cutting problem. Annals of

Operation Research, v.179, p. 297-315, 2010.

OLIVEIRA, J.F.; FERREIRA, J.S. An improved version of Wang’s Algorithm for two-dimensional cutting problems. European Journal of Operational Research, n. 44, p. 256-266, 1990.

OLIVEIRA, J.F.; FERREIRA, J.S. A geração rápida de colunas: uma alternativa na técnica de Gilmore e Gomory para problemas de corte. Investigação Operacional, Lisboa, v. 13, p. 101-117, 1993.

PARADA, V.; PRADENAS, L.; SOLAR, M. Heurísticas Híbridas em Problemas de Corte de Peças. Anais do X Congresso Latino-Ibero-Americano de Investigação Operativa. Cidade do México, 2000.

PRAIS, M.; RIBEIRO, C.C. Reactive GRASP: An application to a matrix decomposition problem in TDMA traffic assignment. INFORMS Journal on Computing, v. 12, n. 3, p. 164-176, 2000.

PUCHINGER, J.; RAIDL, G.R. Models and algorithms for three-stage two-dimensional bin packing. European Journal of Operational Research, v. 183, n. 3, p. 1304-1327, 2007.

RIETZ, J.; SCHEITHAUER, G.; TERNO, J. Tighter bounds for the gap and non-IRUP constructions in the one-dimensional cutting stock problem. Optimization, v. 51, n. 6, p. 927-963, 2002.

SCHEITHAUER, G.; TERNO, J. A branch & bound algorithm for solving one-dimensional cutting stock problems exactly. Applicationes Mathematicae, v. 23, n. 2, p. 151-167, 1995.

SLACK, N.; CHAMBERS, S.; HARLAND, C.; HARRISON, A.; JOHNSTON, R. Administração da produção. 1ª ed. São Paulo: Atlas, 1996.

SILVA, E.; ALVELOS, F.; DE CARVALHO, J.M.V. An integer programming model for two-and three-stage two-dimensional cutting stock problems. European Journal of

Operational Research, v. 205, n. 3, p. 699-708, 2010.

132

SILVEIRA, R. J.; MORABITO, R. A heuristic method based on dynamic programming for the constrained two-dimensional guillotine cutting problem. Gestão & Produção, v. 9, n. 1, p. 78-92, 2002.

VALDÉS, R.A.; PARAJÓN, A.; TAMARIT, J.M. A tabu search algorithm for large-scale guillotine (un)constrained two-dimensional cutting problems. Computers & Operations

Research, n.29, p. 925-947, 2002a.

VALDÉS, R.A.; PARAJON, A.; TAMARIT, J.M. A computational study of LP-based heuristic algorithms for two-dimensional guillotine cutting stock problems. OR Spectrum, v. 24, n. 2, p. 179-192, 2002b.

VALÉRIO DE CARVALHO, J.M. Using extra dual cuts to accelerate column generation. INFORMS Journal on Computing, v. 17, n. 2, p. 175-182, 2005.

VELASCO, A.S. GRASP para o Problema de Corte Bidimensional Guilhotinado e Restrito. Dissertação (Mestrado em Engenharia de Produção) – Centro de Ciências e Tecnologia, Laboratório de Engenharia de Produção – Leprod, UENF, Campos dos Goytacazes, 2005.

VELASCO, A.S.; PAULA JUNIOR, G.G.; VIEIRA NETO, E. Um Algoritmo Heurístico Baseado na GRASP para o Problema de Corte Bidimensional Guilhotinado e Restrito. Revista Gepros - Gestão da Produção, Operações e Sistemas, ed.1, p.129-141, 2008.

VELASCO, A.S.; UCHOA, E. Algoritmos Híbridos para Geração de Padrões de Corte 2D. In: XVIII Escuela Latino-Iberoamericana de Verano en Investigación Operativa, 2014, Areia - PB. Anais do XVIII ELAVIO, 2014a.

VELASCO, A.S.; UCHOA, E. Geração de Padrões de Corte Bidimensionais Guilhotinados via Grasp. In: Simpósio Brasileiro de Pesquisa Operacional, 2014, Salvador - BA. Anais do XLVI SBPO, 2014b.

VELASCO, A.S.; UCHOA, E. Geração de Colunas e GRASP para o Problema de Corte de Estoque Bidimensional. In: Simpósio Brasileiro de Pesquisa Operacional, 2015, Recife - PE. Anais do XLVII SBPO, 2015.

VIEIRA NETO, E. Uma heurística GRASP para o problema do corte unidimensional.

Dissertação (Mestrado em Ciências das Engenharia) – Centro de Ciências e Tecnologia, Laboratório de Engenharia de Produção – LEPROD, UENF, Campos dos Goytacazes, 1999.

VIEIRA NETO, E. GRASP: efeito da independência das soluções iniciais na otimização do

corte unidimensional. Tese (Doutorado em Ciências das Engenharia) – Centro de Ciências e Tecnologia, Laboratório de Engenharia de Produção – LEPROD, UENF, Campos dos Goytacazes, 2004.

VIEIRA NETO, E.; VELASCO, A.S.; PAULA JUNIOR, G.G. Algoritmos Grasp Híbridos para o Problema de Corte Unidimensional. In: Simpósio Brasileiro de Pesquisa Operacional, 2013, Natal/RN. Anais do SBPO, 2013.

WANG, P. Y. Two algorithms for constrained two-dimensional cutting stock problems. Operations Research, n. 31, p. 573-586, 1983.

WÄSCHER, G.; HAUßNER, H.; SCHUMANN, H. An improved typology of cutting and packing problems. European Journal of Operational Research, v. 183, n. 3, p. 1109-1130, 2007.

133

ANEXO – INSTÂNCIAS DOS PADRÕES DE CORTE ILUSTRADOS

Em sequência, as tabelas apresentam informações referentes aos dados das instâncias

utilizadas para produzir os padrões de corte ilustrados nos respectivos Capítulos 4 e 5.

Instância ChW1:

C = 15, L = 10, m = 7

i di (ci, li) vi

1 1 (2, 1) 2 2 2 (3, 2) 8 3 2 (3, 3) 11 4 5 (3, 4) 17 5 3 (8, 2) 24 6 1 (3, 7) 35 7 2 (8, 4) 66

Instância CU2:

C = 150, L = 175, m = 35

i di (ci, li) vi

1 2 (78, 44) 3432 2 2 (64, 70) 4480 3 3 (52, 70) 3640 4 1 (79, 100) 7900 5 1 (66, 60) 3960 6 2 (81, 39) 3159 7 1 (91, 94) 8554 8 4 (66, 56) 3696 9 2 (91, 50) 4550 10 1 (96, 68) 6528 11 3 (40, 112) 4480 12 1 (76, 106) 8056 13 8 (63, 35) 2205 14 2 (86, 60) 5160 15 1 (93, 84) 7812 16 1 (95, 92) 8740 17 1 (70, 57) 3990 18 1 (66, 71) 4686 19 1 (84, 78) 6552 20 4 (51, 67) 3417 21 2 (34, 89) 3026 22 2 (77, 87) 6699 23 4 (44, 66) 2904 24 2 (76, 76) 5776 25 1 (50, 45) 2250 26 4 (36, 66) 2376 27 4 (38, 66) 2508 28 6 (75, 39) 2925 29 1 (77, 103) 7931 30 8 (50, 45) 2250 31 1 (80, 107) 8560 32 5 (61, 54) 3294 33 2 (31, 95) 2945 34 5 (39, 67) 2613 35 1 (63, 102) 6426

Instância OF1:

C = 70, L = 40, m = 10

i di (ci, li) vi

1 1 (29, 5) 145 2 4 (9, 39) 351 3 1 (55, 9) 495 4 1 (31, 15) 465 5 2 (11, 16) 176 6 3 (23, 21) 483 7 4 (29, 14) 406 8 3 (16, 19) 304 9 2 (9, 36) 324 10 2 (22, 4) 88

Instância gcut13:

C = 3000, L = 3000, m = 32

i di (ci, li) vi

1 1 (365, 185) 67525 2 1 (378, 200) 75600 3 1 (410, 165) 67650 4 1 (425, 148) 62900 5 1 (425, 296) 125800 6 1 (439, 116) 50924 7 1 (464, 1006) 466784 8 1 (520, 205) 106600 9 1 (520, 350) 182000 10 1 (540, 530) 286200 11 1 (549, 1413) 775737 12 1 (549, 1882) 1033218 13 1 (553, 496) 274288 14 1 (555, 755) 419025 15 1 (555, 496) 275280 16 1 (555, 659) 365745 17 1 (567, 473) 268191 18 1 (572, 592) 338624 19 1 (572, 975) 557700 20 1 (572, 1175) 672100 21 1 (572, 1575) 900900 22 1 (572, 1390) 795080 23 1 (572, 1490) 852280 24 1 (572, 1590) 909480 25 1 (572, 1690) 966680 26 1 (572, 1890) 1081080 27 1 (610, 625) 381250 28 1 (660, 490) 323400 29 1 (690, 447) 308430 30 1 (949, 445) 422305 31 1 (949, 478) 453622 32 1 (970, 463) 449110

134

Instância APT33:

C = 241, L = 983, m = 44

i di (ci, li) vi

1 3 (46, 129) 5934 2 9 (71, 204) 14484 3 5 (26, 330) 8580 4 6 (15, 72) 1080 5 7 (81, 180) 14580 6 3 (63, 239) 15057 7 6 (54, 302) 16308 8 3 (15, 214) 3210 9 2 (72, 93) 6696 10 9 (59, 154) 9086 11 6 (90, 266) 23940 12 3 (41, 151) 6191 13 1 (70, 281) 19670 14 8 (50, 268) 13400 15 7 (46, 285) 13110 16 2 (49, 263) 12887 17 4 (80, 341) 27280 18 5 (65, 390) 25350 19 5 (89, 52) 4628 20 1 (85, 185) 15725 21 2 (74, 289) 21386 22 8 (18, 379) 6822 23 8 (59, 139) 8201 24 8 (39, 52) 2028 25 3 (83, 98) 8134 26 5 (56, 355) 19880 27 7 (76, 142) 10792 28 4 (81, 371) 30051 29 8 (41, 249) 10209 30 8 (59, 233) 13747 31 3 (38, 279) 10602 32 9 (82, 170) 13940 33 1 (47, 233) 10951 34 4 (77, 274) 21098 35 7 (57, 224) 12768 36 6 (42, 313) 13146 37 7 (37, 135) 4995 38 2 (86, 275) 23650 39 5 (46, 357) 16422 40 1 (19, 270) 5130 41 9 (52, 165) 8580 42 9 (82, 124) 10168 43 2 (68, 257) 17476 44 3 (54, 46) 3024

Instância CW4:

C = 465, L = 387, m = 39

i di (ci, li) vi

1 1 (288, 191) 168 2 8 (112, 177) 328 3 1 (156, 235) 458 4 2 (147, 141) 334 5 2 (236, 181) 696 6 2 (119, 226) 613 7 2 (216, 243) 576 8 4 (152, 132) 435 9 1 (259, 132) 601 10 2 (140, 231) 499 11 2 (155, 228) 557 12 6 (122, 111) 682 13 3 (256, 115) 656 14 1 (289, 222) 292 15 1 (265, 231) 442 16 1 (275, 215) 633 17 1 (297, 205) 152 18 2 (168, 100) 626 19 1 (235, 199) 405 20 3 (236, 111) 547 21 1 (171, 230) 551 22 1 (222, 172) 250 23 1 (265, 209) 169 24 1 (234, 236) 505 25 3 (285, 86) 749 26 7 (144, 79) 191 27 1 (186, 227) 497 28 4 (133, 112) 687 29 1 (253, 163) 236 30 2 (215, 243) 203 31 2 (190, 225) 321 32 1 (212, 183) 519 33 2 (145, 204) 309 34 4 (108, 147) 291 35 5 (151, 96) 155 36 1 (215, 145) 171 37 1 (263, 156) 317 38 1 (208, 153) 180 39 1 (240, 227) 366