Um algoritmo pseudo-polinomial para o problema de geração de padrões de cortes guilhotinados em placas

(1)

Instituto de Computa¸

c˜

ao

Departamento de Ciˆ

encia da Computa¸

c˜

ao

Leonardo da Rocha Perazzini

UM ALGORITMO PSEUDO-POLINOMIAL PARA

O PROBLEMA DE GERA ¸

C ˜

AO DE PADR ˜

OES DE

CORTES GUILHOTINADOS EM PLACAS

Niter´

oi-RJ

2017

(2)

LEONARDO DA ROCHA PERAZZINI

UM ALGORITMO PSEUDO-POLINOMIAL PARA O PROBLEMA DE GERA ¸C ˜AO

DE PADR ˜OES DE CORTES GUILHOTINADOS EM PLACAS

Trabalho submetido ao Curso de Bachare-lado em Ciência da Computa¸cão da Universi-dade Federal Fluminense como requisito par-cial para a obten¸cão do t´ıtulo de Bacharel em Ciência da Computa¸cão.

Orientador: Prof. U´everton dos Santos Souza

Niter´oi-RJ 2017

(3)

(4)

(5)

Dedico este trabalho a todos os amigos e fa-miliares que estiveram ao meu lado durante essa jornada.

(6)

Agradecimentos

Aos meus pais Mauricio Perazzini e Angela Aparecida da Rocha e meu irmão Vin´ıcius que fizeram de tudo e não mediram esfor¸cos para que eu chegasse até aqui.

A minha namorada Dayene Sant’Ana por me apoiar e incentivar durante os per´ıo-dos que escrevi e produzi este trabalho e em todas as situa¸c˜oes em que eu precisei.

Ao meus grandes amigos Erick Vinicius, Daniel Derlando , Luiz Renato e Ralf Schroeder que sempre me apoiaram durante essa trajet´oria na UFF.

Ao professor orientador Uéverton dos Santos Souza, pela paciência, dedica¸cão, orienta¸cão e motiva¸cão durante todas as etapas, que tornaram poss´ıvel a conclusão deste projeto e monografia.

A todos que de alguma forma contribu´ıram para o meu desenvolvimento, serei eternamente grato.

(7)

Resumo

Em um processo de produ¸cão de pe¸cas a partir de uma placa retangular P , o problema de gera¸cão de padrões de cortes guilhotinados consiste em determinar uma sequência de cortes a serem feitos por uma guilhotina em P (padrão de corte) de modo a: gerar um subconjunto de pe¸cas; minimizando o desperd´ıcio de material; e consequen-temente maximizando o lucro da produ¸cão. Motivado pela relevância deste problema na indústria, este trabalho tem como objetivo combinar os conceitos de grafos And-Or e programa¸cão dinâmica para desenvolver um algoritmo capaz de resolver tal problema em tempo pseudo-polinomial. A utiliza¸cão de percursos em grafos And-OR para produ¸cão de um algoritmo pseudo-polinomial, além de ser uma abordagem que ainda não havia sido utilizada na literatura, produz um algoritmo cuja complexidadade de pior caso coincide com o estado da arte para o problema.

Palavras-chave: corte bidimensional guilhotinado em placas, padrão de corte, grafos And-Or, pseudo-polinomial, programa¸cão dinâmica

(8)

Sum´

ario

Resumo vii

Lista de Figuras x

1 Introdu¸c˜ao 1

2 Conceitos Preliminares 3

2.1 An´alise de Complexidade de Algoritmos . . . 3

2.2 Complexidade Computacional . . . 5

2.3 Algoritmos Pseudo-Polinomiais . . . 8

2.4 Programa¸c˜ao Dinˆamica . . . 10

2.5 Problema da Mochila . . . 14

3 Corte Bidimensional Guilhotinado 21 3.1 Introdu¸c˜ao . . . 21

3.2 NP-Dificuldade do Problema do Corte Bidimensional Guilhotinado . . . . 23

3.3 Solu¸c˜ao por grafo And-Or . . . 25

4 Um algoritmo pseudo-polinomial 31 4.1 Prova do algoritmo Pseudo-Polinomial . . . 44

4.1.1 O tempo de execu¸c˜ao do algoritmo . . . 44

4.1.2 O tempo de execu¸c˜ao da cria¸c˜ao do grafo . . . 45

4.2 O tamanho do grafo . . . 46

5 Conclus˜ao 49

(9)

Lista de Figuras

1.1 Exemplo de corte de placa para obter uma pe¸ca . . . 2

2.1 Conjuntos P = N P ou P 6= N P . . . 9

2.2 Algoritmo Counting Sort . . . 11

2.3 Arvore de Recurs˜´ ao . . . 13

2.4 Algoritmo Problema da Mochila Preenchimento . . . 16

2.5 Exemplo Problema da Mochila - Itens . . . 18

2.6 Exemplo Problema da Mochila - Valores Base . . . 18

2.7 Exemplo Problema da Mochila - Algoritmo . . . 20

3.1 Exemplo Cutting Problema - 8 Stage . . . 23

3.2 Redu¸c˜ao Problema da Mochila para Problema do Corte Bidimensional Gui-lhotinado . . . 24

3.3 Exemplo de n´os OU - Grafo And-Or . . . 26

3.4 Exemplo de n´os E - Grafo And-Or . . . 26

3.5 Placa, pe¸cas e padr˜ao de corte . . . 27

3.6 Grafo com um caminho de uma solu¸c˜ao . . . 27

3.7 Limite inferior na estrat´egia de Grafo And-Or para resolu¸c˜ao do Problema do Corte Bidimensional Guilhotinado . . . 28

3.8 Verifica¸cão de corte na estratégia de Grafo And-Or para resolu¸cão do Pro-blema do Corte Bidimensional Guilhotinado . . . 30

4.1 Exemplo da transforma¸cão do problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas para grafo. . . 32

4.2 Exemplo de transforma¸cão impl´ıcita do problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas para grafo. . . 33

(10)

4.3 Exemplo de transforma¸c˜ao para grafo And-Or do problema de Gera¸c˜ao de

Padr˜oes de Cortes Guilhotinados em Placas. . . 34

4.4 Exemplo de Ordena¸c˜ao Topol´ogica. . . 35

4.5 Exemplo de uma placa 3x3 para um grafo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas. . . 36

4.6 Exemplo de uma placa 3x3 para um grafo And-Or -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas. . . 37

4.7 Exemplo de uma placa 3x3 para um grafo And-Or ordenado topol´ ogica-mente -problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas. 38 4.8 Passo 1 - Algoritmo -problema de Gera¸cão de Padrões de Cortes Guilhoti-nados em Placas. . . 39

4.9 Passo 2 - Algoritmo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhoti-nados em Placas. . . 39

4.17 Subgrafo Solu¸cão - Algoritmo - problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas. . . 44

4.18 Cria¸cão do grafo And-Or - Etapa de cria¸cão dos nós And e arestas. . . 46

4.19 ´Area considerada para criar as pe¸cas. . . 47

(11)

Cap´ıtulo 1

Introdu¸

c˜

ao

O problema denominado Gera¸cão de Padrões de Cortes Guilhotinados em Placas, estudado neste trabalho, consiste em determinar a “melhor” forma de cortar, através de uma guilhotina, um material ou placa retangular, a fim de produzir um cojunto de unidades menores.

No ramo industrial este problema aparece diversas vezes nos processos de corte de matérias-primas para a produ¸cão de objetos menores especificados por clientes. Geral-mente os materiais a serem cortados são placas de madeira, chapas de a¸co, fibras de vidro, tecidos, pe¸cas de couro, entre outros.

Esse problema tem sido amplamente estudado na literatura desde meados de 1960, dentre esses trabalhos, podemos citar Gilmore and Gomory (1964) [1], Herz (1972) [2], Beasley (1985) [3], Morabito, Arenales e Arcaro (1992) [4], Silveira e Morabito (2002) [5], Da Bianco e da Silva (2010) [6].

O problema Gera¸cão de Padrões de Cortes Guilhotinados em Placas considera apenas placas e pe¸cas bidimensionais, envolvendo portanto apenas duas dimensões rele-vantes para a sua resolu¸cão (comprimento e largura). O problema considera apenas cortes guilhotinados, ou seja cortes que dividem uma placa retangular em duas outras placas re-tangulares menores. Tal restri¸cão segue da caracter´ıstica dos equipamentos comumente utilizados no mundo real. Notem que um corte guilhotinado produz dois novos retângulos onde os retângulos resultantes possuem uma dimensão de comprimento igual ao da pe¸ca de origem. Além disso, nesse problema não há limita¸cão de número de cortes que podem ser feitos para obten¸cão de uma pe¸ca a partir de uma placa.

(12)

Figura 1.1: Exemplo de corte de placa para obter uma pe¸ca (ilustra¸cão retirada de [5]). Devido à dificuldade do problema e por ele ser classificado como NP-Dif´ıcil, neste trabalho foi necessário um estudo mais aprofundado sobre Análise de Complexidade, além de problemas e técnicas que pudessem ajudar na resolu¸cão e entendimento do problema. Por fim, combinando os conceitos de grafo And-Or e programa¸cão dinâmica, desenvol-vemos um algoritmo exato capaz de resolver o problema em tempo pseudo-polinomial, sendo esta a principal contribui¸cão deste trabalho.

Sendo assim, os cap´ıtulos restantes desta monografia são dividos da seguinte forma. No Cap´ıtulo 2 introduzimos os conceitos teóricos relevantes para o desenvolvimento do trabalho, tais como conceitos associados a complexidade e análise de algoritmos e exem-plifica¸cões - construindo assim um conhecimento preciso para a produ¸cão do nosso al-goritmo; no Cap´ıtulo 3 apresentamos formalmente o problema Gera¸cão de Padrões de Cortes Guilhotinados em Placas e descrevemos como o mesmo é comumente solucionado na literatura; No Cap´ıtulo 4 criamos uma solu¸cão para o problema e provamos que seu tempo de execu¸cão é pseudo-polinomial; por fim aprensentamos as considera¸cões finais.

(13)

Cap´ıtulo 2

Conceitos Preliminares

2.1 An´

alise de Complexidade de Algoritmos

A fim de tornar o trabalho autocontido, nessa se¸cão será apresentado um recorte dos conceitos de Análise e Complexidade de Algoritmos apresentados em [7].

Um algoritmo é um processo sistemático para a solu¸cão de um problema, sendo esse processo de vital importância para problemas a serem resolvidos por computadores. Existem dois tópicos básicos no estudo de algoritmos: a corre¸cão e a análise. A corre¸cão consiste na verifica¸cão da exatidão do algoritmo para resolver o problema proposto, sendo realizado através de uma prova matématica. A análise busca a obten¸cão de ”variáveis”que possam avaliar a eficiência do algoritmo em rela¸cão a tempo de execu¸cão e memória utilizada no processo de resolu¸cão do problema [7].

O tempo de execu¸cão de um algoritmo pode ser determinado de duas formas: método emp´ırico e método anal´ıtico. O primeiro trata de obter o tempo através da execu¸cão do algoritmo por meio de diversos tipos de entrada. Em contrapartida, o segundo modo obtém uma ordem de grandeza do tempo de execu¸cão, isto é , uma expressão matématica que traduza o comportamento do tempo de um algoritmo. Ao contrário do método emp´ırico, o análitico independe de um computador, linguagem ou compilador empregados, para se saber o tempo de execu¸cão [7].

As seguintes simplifica¸cões são introduzidas para que o modelo análitico seja obtido [7]:

– Supor que a quantidade de dados manipulados pelo algoritmo seja suficientemente grande, isto é, a entrada dos algoritmos só serão avaliadas se tiverem comportamento

(14)

assint´otico ( quantidade de dados tender a infinito).

Consequentemente, não são consideradas constantes aditivas ou multiplicativas nas expressões matématicas obtidas.

Um algoritmo opera a partir de uma entrada para produzir uma sa´ıda, desta forma, seu tempo de execu¸cão pode ser descoberto em fun¸cão da entrada. O processo de exe-cu¸cão de um algoritmo pode ser dividido em etapas elementares, os passos. Cada passo consiste na execu¸cão de um conjunto fixo de opera¸cões básicas cujo tempo de execu¸cão é constante. A opera¸cão com maior frequência na execu¸cão do algoritmo é denominada opera¸cão dominante. Como a expressão de tempo de execu¸cão do algoritmo é obtida desconsiderando constantes aditivas e multiplicativas, e consideram-se apenas os passos que sejam opera¸cõs dominantes [7]. Assim sendo, a expressão matématica que representa e avalia o tempo de execu¸cão é uma fun¸cão que fornece o número de passos (opera¸cõs dominantes) efetuados pelo algoritmo a partir da uma entrada.

A seguir apresentamos a no¸c˜ao de complexidade de tempo de um algoritmo con-forme apresentado por Jayme Luiz Szwarcfiter e Lilian Markenzon em [7]:

Defini¸c˜ao 1. ( [7] ) Seja A um algoritmo, { E1,...,Em } o conjunto de todas as entradas

poss´ıveis de A. Denote por ti, o n´umero de passos efetuados por A, quando a entrada for

Ei. Definem-se:

• Complexidade do pior caso = maxEi∈E {ti}

• Complexidade do melhor caso = minEi∈E {ti}

• Complexidade do caso m´edio = P

1≤i≤m pi ti,

onde pi ´e a probabilidade de ocorrˆencia da entrada Ei

A nota¸cão O é utilizada para exprimir no¸cões de complexidades, podendo ser de pior, melhor ou caso médio. Sejam f, h fun¸cões reais positivas de váriavel inteira n. Diz-se que f é O(h), registrando f = O(h), quando existir uma constante c > 0 e um valor inteiro n0, de modo que

n > n0 ⇒ f (n) ≤ c.h(n) (2.1)

Ou seja, a fun¸cão h atua como limite superior para valores assintóticos da fun¸cão f. A seguir alguns exemplos retirado de [7] exemplificando a nota¸cão O.

(15)

f = n2− 1 ⇒ f = O(n2) f = n2− 1 ⇒ f = O(n3₎

f = 403 ⇒ f = O(1)

f = 5 + 2 log₂n + 3 log2₂n ⇒ f = O(log2₂n) f = 5 + 2 log₂n + 3 log2₂n ⇒ f = O(n) f = 3n + 5 log₂n + 2 log2₂n ⇒ f = O(n)

f = 5.2n+ 5n10 ⇒ f = O(2n₎

Sabendo que a express˜ao f = O(h) tem o mesmo significado que ”f ≤ h”, precisamos definir o conceito que signifique ”f ≥ h”.Logo, temos que f = Ω(h) se

n > n0 ⇒ f (n) ≥ c.h(n) (2.2)

2.2 Complexidade Computacional

A análise de complexidade de algoritmos é estudada na análise de algoritmos es-pec´ıficos. A teoria da complexidade, por sua vez, estuda a classifica¸cão de problemas com base na complexidade dos poss´ıveis algoritmos que os resolvem.

Um algoritmo é qualificado como sendo polinomial quando sua complexidade é uma fun¸cão polinomial no tamanho da entrada do problema, sendo assim, se a fun¸cão for exponencial ou fatorial, o algoritmo também será exponencial ou fatorial [8]. Um algoritmo é eficiente quando sua complexidade é um polinômio no tamanho da entrada. Em outras palavras, para um algoritmo ser polinomial, o número de passos que ele deve efetuar no pior caso, não deve ultrapassar um valor polinomial com rela¸cão à entrada.

(16)

Isto é, o número de passos efetuado pelo algoritmo, para qualquer que seja a entrada, deve ser menor ou igual a nc , onde n é o tamanho da entrada e c é uma constante.

Podemos citar alguns exemplos de algoritmos de busca e ordena¸c˜ao e suas comple-xidades:

1 – Busca Sequencial – O(n) – Polinomial 2 – Busca Bin´aria – O(log₂n) – Polinomial 3 – Ordena¸c˜ao Bolha – O(n2_{) – Polinomial}

4 – Ordena¸c˜ao MergeSort – O(nlog₂n) – Polinomial

Algoritmos de complexidade exponenciais, possuem fun¸c˜ao cn_{, sendo c>1.}

Algoritmos com complexidade não-polinomial demandam tal quantidade de tempo para execu¸cão, que mesmo instâncias de tamanho relativamente pequeno, não podem ser resolvidos sem ter executado um longo tempo para sua resolu¸cão. Na tabela 2.2, podemos visualizar os gastos para alguns exemplos de complexidade.

Tabela 2.1: Tabela de Complexidades. Considere que cada opera¸c˜ao leve 1ms. Tabela retirada de Siang Wun Song - Universidade de S˜ao Paulo - IME/USP [9]

n f1(n)=n f2(n)=nlog2n f3(n)=n2 f4(n)=n3 f5(n)=2n

16 0.016s 0.064s 0.256s 4s 1m4s

32 0.032s 0.16s 1s 33s 46dias

512 0.512s 9s 4m22s 1d13h 10137 _anos

Algoritmos podem ser classificados segundo suas complexidades, podendo ser in-decid´ıvel, intrat´avel ou trat´avel.

Problemas Indecid´ıveis são problemas tão dif´ıceis que não pode ser criado nenhum algoritmo para resolvê-los, como por exemplo o problema da parada e Turing. Intratáveis são os problemas que admitem algoritmos para resolvê-los, mas provalvemnte não existe um algoritmo que os resolva em tempo polinomial. Tratáveis são os problemas que pos-suem algoritmos de tempo polinomial que o resolvem. Problemas Intratáveis e Tratáveis são problemas ditos decid´ıveis [8].

Os problemas também podem ser classificados como Problemas de Decisão, Loca-liza¸cão e Otimiza¸cão.

Problemas de Decisão: São aqueles que consistem na verifica¸cão de determinada questão para o problema, isto é, verificar a existência de alguma propriedade para a

(17)

entrada, tendo como resposta Sim ou N˜ao.

Problemas de Localiza¸cão: São aqueles que consistem em identificar/localizar a partir da entrada, caso exista, alguma estrutura que forne¸ca uma solu¸cão para o problema. Problema de Otimiza¸cão: São aqueles que consistem em determinar o valor/custo da melhor solu¸cão poss´ıvel entre todas as poss´ıveis solu¸cões viáveis do problema.

Assim sendo problemas de decisão são a forma mais simples de problema compu-tacional, uma vez que os de Localiza¸cão e Otimiza¸cão contém a mesma verifica¸cão de existência de uma solu¸cão para o problema, logo o problema de decisão não possui maior dificuldade dos que os outros dois. Portanto os problemas sao classificados em classes a partir do tempo necessário para resolvê-lo, e o tempo necessário para verificar se uma poss´ıvel estrutura da entrada é de fato um comprovante válido para a resposta/solu¸cão do problema [8].

A classe P : Um problema de decisão pertence à classe P, se e apenas se ele for resolvido em tempo Polinomial por um algoritmo determin´ıstico [10]. Isto é, o problema aceita um algoritmo com complexidade de pior caso polinomial.

A classe NP : Um problema de decisão pertence à classe NP (nondeterministic polynomial), se o problema é polinomialmente verificável, isto é, o problema admite uma estrutura denominada certificado , qual podemos verificar em tempo polinomial, onde após a comprova¸cão de sua validade, podemos afirmar que a resposta para a questão a ser respondida é sim [11].

Se um problema pertence à classe P então ele também pertence à classe NP, pois se um problema pode ser resolvido em tempo polinomial por um algoritmo. Uma poss´ıvel sa´ıda desse algoritmo pode ser utilizada como certificado, e sua valida¸cão baseia-se em executar o algoritmo e comparar as respostas. Todo esse processo pode ser feito em tempo polinomial, portanto P ⊆ N P

Para o completo entendimento das classes NP-Completo e NP-Dif´ıcil, é impor-tante o estudo de redu¸cão e complexidade relativas aos problemas. Como para muitos problemas em NP é desconhecido um algoritmo polinomial, uma boa idéia é investigar a complexidade relativa dos problemas da classe NP, ou seja, verificar se um dado problema A é mais fácil ou mais dif´ıcil que um outro problema B em NP. Usando a idéia de redu-¸cão polinomial, dizemos que um problema A não é mais dif´ıcil que ( ou polinomialmente redut´ıvel a) um problema B, se existe um algoritmo que:

(18)

• Transforma uma entrada Io do problema A , em tempo polinomial, numa instˆancia

f (I) do problema B.

• A resposta do problema B para a instância f (I) é sim, se e somente se a resposta de A para a instância I é sim.

Note que se A não é mais dif´ıcil que B, e B está na classe P, A também estará em P. [11]. A classe NP-Completo: Um problema de decisão A ∈ NP, pertence a classe NP-Completo se todos os outros problemas em NP se transformam polinomialmente em A [8] – Fortemente NP-Completo: Quando comprovado que o problema não pode ser resolvido por um algoritmo de tempo pseudo-polinomial, a menos que P = N P – Fracamente NP-Completo: É quando o problema NP – Completo possui um

algoritmo pseudo-polinomial que o resolva.

A classe NP-Dif´ıcil : Um problema A pertence a classe NP-Dif´ıcil se existe um problema B em NP-Completo que pode ser transformado em A em tempo polinomial [8].

Em outras palavras, a diferen¸ca entre problemas NP-Completos e NP-Dif´ıceis é que para os NP-Completos temos provas de pertinência na classe NP, enquanto para os NP-Dif´ıceis certificados verificáveis em tempo polinomial não necessariamente são conhecidos [8]. Todo problema NP-completo é NP-Dif´ıcil. Além disso, problemas de otimiza¸cão, cuja versão de decisão é NP-Completo, são também considerados NP-dif´ıficeis

A grande questão da Computa¸cão é se P = N P ? Ou seja, N P ⊆ P , o que implicaria em todos os problemas da classe NP serem tratáveis. Veja na figura 2.1

2.3 Algoritmos Pseudo-Polinomiais

Para o estudo dos problemas propostos neste trabalho, precisamos antes entender melhor o conceito de algoritmos Pseudo-Polinomiais. Consideremos a complexidade O(n∗ M ), onde n é o tamanho da entrada e M é um inteiro da entrada. Sabemos que o inteiro M faz parte (está contido) na entrada e que n pode ser menor do que M . Isso ocorre porque quando dizemos que M é um inteiro da entrada, isto significa que o valor M é uma informa¸cão que pode ser obtida a partir de dados da entrada. Esse valor é representado por uma quantidade de bits, log₂M , note que M = 2log2M. Logo a entrada contém

(19)

Figura 2.1: Imagem representando as classes como conjuntos, caso seja P = N P ou P 6= N P .

Assim sendo um algoritmo O(n ∗ log₂M ) é um algoritmo polinomial com rela¸cão ao tamanho da entrada, mas O(n ∗ M ) pode não ser polinomial com rela¸cão ao tamanho da entrada (n). Por exemplo: Sendo M = 2n _ser˜_{ao necess´}_{arios n bits para represent´}_a-lo,

sendo O(n) o tamanho da entrada, mas como a informa¸cão é relevante para a complexidade e não como esta representada em bits, temos O(n ∗ M ) = O(n ∗ 2n_{) que ´}_{e exponencial em}

rela¸c˜ao ao tamanho da entrada.

Assim sendo o algoritmo é exponencial, mas em caso de um M “pequeno” o algo-ritmo se comporta como um algoalgo-ritmo polinomial. Um modo mais formal de defini¸cão apresentada por Gennady Shmonin em [12], é que um algoritmo A que resolva um pro-blema de decisão P é dito Pseudo-Polinomial quando a complexidade de A for polinomial no tamanho da entrada de P , supondo que esta seja codificada em um alfabeto unário. Podemos citar como exemplos de algoritmos Pseudo-Polinomiais para melhor entendi-mento do conceito, o algoritmo que resolve o Problema da Mochila que veremos com mais detalhes no cap´ıtulo 2.5 que falaremos sobre o Problema da Mochila e o algoritmo Counting Sort que resolve o problema de ordena¸cão.

(20)

Exemplo

Algoritmo Counting Sort : O algoritmo consiste na ordena¸cão de um vetor de valores do tipo inteiro, baseando-se em indexa¸cão e não em compara¸cões como algoritmos clássicos como Quicksort ou Bubble sort. O algoritmo parte do principio que o valor do maior elemento do vetor, k, é conhecido e com rela¸cão ao número de elementos do vetor cria-se um vetor auxiliar de k posi¸cões para que o algoritmo crie um vetor auxiliar para contagem dos elementos. O ideal é valor de k manter-se linear, caso isso ocorra o algoritmo se comporta de forma linear, caso o k seja muito maior que o tamanho do vetor ou exponencialmente maior, o algoritmo torna-se exponencial pois a necessidade de criar e percorrer um vetor de k posi¸cões faz o algoritmo ter tempo exponencial. Como a complexidade do Counting Sort além de depender do número de elementos, também depende da grandeza do maior elemento do vetor, temos que o Counting Sort é um algoritmo Pseudo-Polinomial.

Abaixo podemos ver o pseudo-código e o custo dos blocos de código, retirado de [13] e uma ilustra¸cão na figura 2.2 para melhor entendimento do algoritmo retirado de [14].

• O(k) - É criado um vetor de trabalho e se atribui o valor zero à todas posi¸cões desse vetor auxiliar

• O(n) - Nessa etapa será feita a contagem do número de cada elemento do intervalo. Caso o 1 aparece duas vezes, dentro da casa 1 será feito o incremento duas vezes. • O(n) - Por fim, percorre-se o vetor B inserindo de forma ordenada em A, os valores

dos ´ındices de B, conforme o seu n´umero de ocorrˆencias no vetor A.

2.4 Programa¸

c˜

ao Dinˆ

amica

Problemas computacionais muitas vezes admitem rela¸cões de recorrências que des-crevem uma maneira de resolver o problema através da resolu¸cão de subproblemas.

Essas rela¸cões de recorrências naturalmente sugerem algoritmos baseados em divi-são e conquista para resolver o problema, isto é, o problema é decomposto em instâncias menores (subproblemas) que devem ser resolvidas para a solu¸cão do problema principal. Por sua vez, esses subproblemas também são decompostos em outros subproblemas que

(21)

Figura 2.2: Ilustra¸c˜ao do algoritmo Counting Sort e seus passos [13].

devem ser resolvidos para que o superproblema possa ser resolvido, e assim sucessiva-mente, até encontrar subproblemas que possuam uma solu¸cão trivial do problema (caso base), ou seja, problemas para o qual não é necessário fazer nenhuma decomposi¸cão para resolvê-los.

Algoritmos de divisão e conquista algumas vezes podem ser ineficientes, pelo fato de em sua resolu¸cão, termos que resolver um mesmo subproblema desnecessariamente pois em alguns casos, um dado problema já pode ter sido resolvido em um instante anterior, logo resolucionar um mesmo problema seria uma computa¸cão desnecessária.

Uma alternativa para contornar esse tipo de problema é utilizar o método da pro-grama¸cão dinâmica. Por defini¸cão o paradigma de program¸cão dinâmica possui algumas carecter´ısticas distintas, sendo que para existir um modo de aplicar a programa¸cão dinˆ a-mica, o problema também deve apresentar uma recorrência , outra caracter´ıstica é que o algoritmo constru´ıdo deve de algum modo percorrer algum tipo de estrutura de dados como uma tabela, onde inicializando os valores dos subproblemas triviais na tabela,

(22)

pode-mos em alguma ordem descobrir o valor dos outros subproblemas, apenas consultando os resultados já gravados na tabela que são necessários para a resolu¸cão do problema atual. Geralmente o tempo de execu¸cão do algoritmo é linearmente proporcional ao tamanho da tabela [15].

Exemplo

Para exemplificarmos o uso da programa¸cão dinâmica usaremos o problema ma-tématico da sequência de fibonacci e os métodos de resolu¸cão do problema. A seguir apresentamos a defini¸cão formal da sequência de fibonacci.

Defini¸c˜ao 2. Sequˆencia de Fibonacci:

(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...) F´ormula de Recorrˆencia:

F (n) =          1 se n = 1 1 se n = 2 F (n − 1) + F (n − 2) se n ≥ 3

Podemos resolver o problema por Divisão e Conquista (Top-Down) ou Programa¸cão Dinâmica (Bottom-Up).

Solu¸c˜ao Recursiva (Divis˜ao e Conquista): i n t f i b ( c o n s t i n t n ) { Se ( n <= 2 ) r e t u r n a 1 ; E n t o r e t u r n a f i b ( n−1 ) + f i b ( n−2 ) ; }

Na Figura 2.3 ser visto a árvore de recursão do problema da sequência de fibonacci. Agora vamos calcular um limite inferior para o tamanho da árvore de recursão constru´ıda pelo algoritmo.

(23)

Figura 2.3: Árvore de Recursão Fibonacci [16]. • Cálculo limite inferior

T (0) = T (1) = 1

Sendo T (n − 1) ≥ T (n − 2) temos: T (n) ≥ 2T (n − 2) + c k = 1

T (n) ≥ 2{2T (n − 4) + c} + c ( Uma instˆancia chamando uma subinstˆancia menor) T (n) ≥ 4T (n − 4) + 3c k = 2

T (n) ≥ 8T (n − 6) + 7c k = 3 T (n) ≥ 16T (n − 8) + 15c k = 4 T (n) ≥ 32T (n − 10) + 31c k = 5 T (n) ≥ 2KT (n − 2K) + (2K − 1)c

Fazendo n − 2K = 0 temos K = n/2 Logo: T (n) ≥ 2n/2T (0) + (2n/2− 1)c

T (n) ≥ (1 + c)2n/2+ c Portanto T (n) = Ω(2n/2)

Podemos assim concluir que o algoritmo de fibonacci recursivo possui complexidade Ω(2n/2_{) provando assim que ´}_{e n˜}_{ao ´}_{e uma boa maneira para resolver o problema. Na}

(24)

pois já haviam sido feitas em outro momento, como por exemplo o cálculo de F ib(2) três vezes na árvore.

Abaixo podemos ver um algoritmo de Programa¸cão Dinâmica (Bottom-Up) que resolve o problema da sequência de fibonacci.

Solu¸cão Iterativa (Programa¸cão Dinâmica ): v e t o r f i b ( i n t n ) { v e t o r V; V [ 1 ] := 1 ; V [ 2 ] := 1 ; Para i :=3 a t é n f a ¸c a Vvi ] := V[ i −1] + V[ i − 2 ] ; r e t u r n V; }

O algoritmo para descobrir o valor do i-ésimo elemento da sequência de Fibonacci F [i], deve para cada i, onde 1 ≤ i ≤ n, percorrer a tabela ( no caso, um vetor) e ir preenchendo o valor do F [i] na tabela com os dois elementos anteriores já preenchidos no vetor, iterando em i até chegar em n e descobrir o valor desejado do i-ésimo somando os dois elementos anteriores.

2.5 Problema da Mochila

Nesta sess˜ao estudaremos uma variante do Problema da Mochila, o Problema da Mochila Booleana ou Problema da Mochila Zero-Um. O problema consiste em dada uma mochila de capacidade W , sendo este um valor inteiro, e um conjunto de n itens cada um com tamanho wi (inteiro) e um valor ci associado, queremos determinar um conjunto de

itens a serem colocados na mochila de modo a maximizar o valor total transportado pela mochila, respeitando a sua capacidade limite [17]. O problema é dito Zero-Um pelo fato de cada item ter apenas dois status, o objeto está ou não está na mochila, não pode ser colocado uma parte/fra¸cão do objeto na mochila.

(25)

• Pn

i=1wi ≤ P

• 0 < wi < W , para todo i = 1,..., n.

O Problema da Mochila admite uma subestrutura ´otima, sendo ela descrita como [17]:

• Se o item n estiver na solu¸cão ótima, o valor desta solu¸cão será cn mais o valor da

melhor solu¸c˜ao do problema da mochila com capacidade de W − wi considerando

apenas n − 1 primeiro itens.

• Se o item n não estiver na solu¸cão ótima, o valor será dado pelo valor da melhor solu¸cão do problema da mochila com capacidade W considerando apenas os w − 1 primeiros itens.

• Seja z[k,d] o valor ótimo do problema da mochila considerando-se uma capacidade d para a mochila que contém um subconjunto dos k primeiros itens da instância da mochila original.

• Assim obtemos a formula de recorrˆencia de z[k,d] para todo k e d:

z[k,d] =                0 se k = 0 0 se d = 0 z[k − 1,d] se wk> d max{z[k − 1,d],z[k − 1,d − wk] + ck} se wk ≤ d

– Se k = 0 a mochila tem 0 itens para serem colocados nela independente do tamanho dela.

– Se d = 0 a mochila tem tamanho 0 independente de quantos itens existam para ser colocados.

– Se wk > d o k-´esimo item n˜ao cabe na mochila, logo devemos olhar para os

”k-1”primeiros itens.

– Se wk ≤ d cálcula o máximo entre os casos de o item estar ou não na mochila.

Dada a recorrˆencia ´e possivel construirmos um algoritmo recursivo para o problema, mas em seu pior caso temos a complexidade de Ω(2n/2_{), isto ´}_{e, n˜}_{ao ´}_{e uma solu¸c˜}_{ao boa para}

(26)

o problema. Assim como no problema da sequência de fibonacci existe a sobreposi¸cão de subproblemas, ou seja, o cálculo repetido de um mesmo subproblema.

A solu¸cão para evitar este problema é o uso de programa¸cão dinâmica. Assim sendo, usaremos uma tabela (matriz) para computar os dados que obtivermos na resolu¸cão dos subproblemas. Para se descobrir a instância atual do problema z[k,d], é necessário as solu¸cões de z[k − 1,d] e z[k − 1,d − wk], ou seja, é necessário sempre um elemento

imediatamente acima (o item não está na mochila) ou em qualquer posi¸cão da linha acima sem o imediato acima (o item está na mochila), logo devemos preencher a matriz linha a linha para que consigamos construir totalmente a matriz. Abaixo podemos visualizar a figura 2.4 de como é feito o preenchimento e o pseudo código retirado de [17].

Figura 2.4: Ordem de preenchemento da matriz do Problema da Mochila [17].

(27)

Entrada:Vetores c e w com o valor e tamanho de cada item, capacidade W da mochila e n´umero de itens n.

P ro ble ma M oc h ila ( c , w, W, n ) {

para d := 0 at´e W fa¸ca z[0, d] := 0

para k := 1 at´e n fa¸ca z[k, 0] := 0

para k := 1 at´e n fa¸ca para d := 1 at´e W fa¸ca

z[k, d] := z[k−1, d]

se (wk ≤ d) e (ck+ z[k − 1, d − wk] < z[k, d]) ent˜ao

z[k, d] := ck+ z[k − 1, d − wk]

devolva ( z [ n , W] )

Sa´ıda: O valor m´aximo do total de itens colocados na mochila.

Ap´os o resultado do algoritmo acima e do preenchimento da matriz, podemos atrav´es do algoritmo abaixo percorrer a tabela e encontrar os itens que foram de fatos colocados na mochila.

Entrada: Tabela z preenchida, capacidade W e o n´umero de itens n. M o c h i l a S o l u c a o ( z , n , W)

{

para i := 0 até n fa¸ca x[i] := 0 M o c h i l a S o l u c a o A u x ( x , z , n ,W) devolva ( x ) } M o c h i l a S o l u c a o a u x ( x , z , n , W) { se k 6= 0 então se z[k,d] = z[k − 1,d] então x[k] := 0

(28)

M o c h i l a S o l u c a o A u x ( x , z , n ,W) sen˜ao

x[k] := 1

M o c h i l a S o l u c a o A u x ( x , z , n ,W) }

Sa´ıda: O vetor x que indica os itens colocados na mochila.

Exemplo

Abaixo mostraremos um exemplo do Problema da Mochila considerando uma mo-chila de peso igual a 7 e o conjunto de itens com valores de c = {10,7,25,24} e w = {2,1,6,5}, como demonstrado na figura 2.5

Figura 2.5: Exemplo Problema da Mochila - Itens. [18]

Podemos ver na figura 2.5 que primeiramente na matriz que computamos os dados das solu¸c˜oes dos subproblemas, iremos inicializar os valores com os casos base, isto ´e, quando d = 0 e k = 0.

Figura 2.6: Exemplo Problema da Mochila - Passo 1. [18]

Nas figuras abaixo podemos ver alguns exemplos dos passos que o algoritmo ir´a fazer para preencher a tabela, e iremos estudar os casos de cada elemento z[k,d].

• Figura 2.7(a) - w1 > d? 2 > 1? Sim, logo n˜ao ´e possivel colocar na mochila.

(29)

• Figura 2.7(b) - w1 > d? 2 > 2? N˜ao, assim devemos calcular o m´aximo entre os

valores poss´ıveis para este item (ele est´a ou n˜ao na mochila). – z[k − 1,d − wk] + cK = z[0,0] + 10 = 0 + 10 = 10 .

– z[k − 1,d] = z[0,2] = 0 – max(10,0) = 10

• Figura 2.7(c) - Após obtermos o resultado da matriz, queremos descobrir o valor máximo para a mochila, no nosso caso 4 itens e mochila de tamanho 7, z[4,7]. w4 > d? 5 > 7? Não, assim devemos calcular o máximo entre os valores poss´ıveis

para este item (ele est´a ou n˜ao na mochila). – z[3,2] + c4 = 10 + 24 = 34 .

– z[3,7] = 32 – max(34,32) = 34

Para obtermos a composi¸cão é simples, basta guardarmos os apontadores dos itens que foram colocados na mochila. Conclu´ımos assim que o algoritmo de Programa¸cão Di-nâmica do Problema da Mochila tem complexidade O(nW ) pelo fato do mesmo depender do valor do peso da mochila W , isto é, precisamos criar uma matriz e percorrer uma matriz com tamanho dependente de quantos itens existem no problema e tamanho da mochila (W ). Assim, dizemos que é um algoritmo Pseudo-Polinomial

(30)

(a) Problema da Mochila - Passo 2. [18]

(b) Problema da Mochila - Passo 3. [18]

(c) Problema da Mochila - Descobrindo o valor m´aximo transportado pela Mochila com os n Itens. [18]

(31)

Cap´ıtulo 3

Corte Bidimensional Guilhotinado

3.1 Introdu¸

c˜

ao

No ramo industrial existem processos de produ¸c˜ao ligados ao corte de mat´ eria-prima, geralmente de tamanho grande e padronizado, em itens de tamanhos menores, para atender a algum tipo de demanda interna ou externa, podendo esses itens serem de tamanhos variados e n˜ao padronizados.

Como exemplos de materiais a serem cortados, podemos citar madeira, vidro, a¸co, tecido. Padrões de cortes adequados da matéria-prima são essenciais para manter uma indústria competitiva no mercado, uma vez que minimizando o desperd´ıcio de material ou minimizando o número de cortes necessários para obter certa pe¸cas, estamos melhorando assim o desempenho de uma produ¸cão, assim como minimizando os gastos da indústria e consequentemente maximizando seus lucros. [6]

Este problema é classificado academicamente como Problema de Cortes e Empaco-tamentos (PCE). Os PCE’s são problemas conbinatórios que são geralmente NP-Dif´ıceis. Isto é atribu´ıdo ao fato de existir uma explosão combinátoria de arranjos poss´ıveis para que possa ser determinado o arranjo ótimo. [6]

Neste cap´ıtulo estudaremos o Problema do Corte Bidimensional Guilhotinado Res-trito um tipo espef´ıfico de PCE. O problema consiste no corte de uma placa retangular de dimens˜oes (L,W ) em pe¸cas retangulares menores (li,wi), estas possuem valores de

uti-lidade π, i = 1,2,3, ..., m, de modo a maximizar a soma dos valores de utiuti-lidade das pe¸cas recortadas. Um conjunto de itens menores que foram produzidos atrav´es de uma sequˆ en-cia de cortes a partir da placa inien-cial (L,W ) define um padr˜ao de corte. Pe¸cas que diferem

(32)

das pe¸cas que queremos obter (li,wi), s˜ao consideradas restos ou res´ıduos. [4]

Se o valor ultidade de cada objeto pi for igual a ´area do objeto, ent˜ao maximizar

o valor utilidade corresponde a minimizar o desperd´ıcio de material.

Defini¸c˜ao 4. ( [4] ) Seja ai uma das pe¸cas produzidas (li,wi), o problema pode ser definido

como: max g = m X i=1 πiai

Correspondem ao padr˜ao de corte.

A entrada do problema consiste nas dimensões da placa inicial (L,W), a quantidade de pe¸cas pré-definidos (m) e as suas dimensões (li,wi).

A sa´ıda do problema consiste numa estrutra que represente quais cortes devem ser feitos na placa, para obter o melhor padr˜ao de corte.

Uma restri¸cão existente no problema é que cada corte produz apenas dois retˆ an-gulos, chamados de cortes de guilhotina. Se existir um limite superior para o número de cortes possiveis para obter as pe¸cas que queremos, o problema é chamado de restrito (“staged”) , se não houver limites para quantos cortes pode-se fazer na placa, o problema é denominado (“non-staged”). Na figura 3.1 podemos ver um padrão de corte restrito de 8 cortes. O primeiro corte é feito de forma paralela a uma das bordas da placa, o próximo é feito perpendicular ao corte já feito e assim por diante, até chegar ao número do limite de cortes poss´ıveis, neste caso oito. Vale ressaltar que não há nenhum impedimento para que haja apenas cortes paralelos, caso as pe¸cas desejadas sejam obtidas por estes cortes, por exemplo uma placa dividida em três pe¸cas (w,i) iguais podem ser feita com três cortes paralelos sem necessidade de cortes perpendiculares entre cortes.

(33)

Figura 3.1: Exemplo Problema do Corte Bidimensional Guilhotinado - 8 Stages. Imagem retirada de [4]

3.2 NP-Dificuldade do Problema do Corte

Bidimen-sional Guilhotinado

Nesta sess˜ao provaremos que o Problema da Mochila se reduz ao Problema do Corte Bidimensional Guilhotinado.

Teorema 1 (Mochila ∝ CorteBidimensionalGuilhotinado).

Inicualmente a entrada do Problema da Mochila é transformada em uma instância do Problema do Corte Bidimensional Guilhotinado em tempo polinomial. O Problema da Mochila possui apenas uma dimensão, ou seja, o peso de cada objeto e o peso da mochila. Se imaginarmos o problema como o peso sendo uma dimensão do problema e outra dimensão sendo 1, temos uma instância do Problema do Corte Bidimensional Guilhotinado, como podemos ver na figura 3.2. Além disso, fazemos o valor utilidade da pe¸ca igual ao valor do objeto.

(34)

Figura 3.2: Redu¸c˜ao Problema da Mochila para Problema do Corte Bidimensional Gui-lhotinado

.

Seja I uma instˆancia do problema da mochila e I’ a instˆancia de Corte Bidimensi-onal Guilhotinado obtida a partir de I◦ como descrito anteriormente.

⇒ Se I (Problema sem estar transformado) possui solu¸cão de valor k, então devemos mostrar que I’ ( Problema transformado) também possui solu¸cão de valor k.

Se a mochila de I possui solu¸c˜ao composta pelos objetos o1, o2, ..., oj com valores

v1, v2, ..., vj, no qual a soma dos valores ´e igual a k, ent˜ao utilizando apenas cortes

hori-zontais, a placa poder´a ser cortada em pe¸cas de valor utilidade v1, v2, ..., vj e a solu¸c˜ao do

problema ter´a o valor utilidade total igual a k.

⇐ Se I’ (Problema sem estar transformado) possui solu¸cão de valor k, então I ( Problema transformado) possui solu¸cão de valor k. Como tanto a placa quanto as pe¸cas possuem altura 1, nenhum corte horizontal será necessário. Sendo assim, por um raciocinio análogo ao anterior se I’ possui solu¸cão de valor utilidade igual a k, então I também possui

(35)

solu¸c˜ao de valor k.

Corol´ario 2. Problema do Corte Bidimensional Guilhotinado ´e NP-Dif´ıcil.

Uma conhecida redu¸cão de Subset Sum para o Problema da Mochila demonstra que a mochila é NP-Dif´ıcil mesmo quando os valores dos objetos são iguais aos seus pesos. Disso, temos como consequência o fato de nosso problema ser NP-Dif´ıcil mesmo quando o valor utilidade de cada pe¸ca é igual a sua área, versão em que desejamos minimizar o desperd´ıcio de material.

3.3 Solu¸

c˜

ao por grafo And-Or

Nesta se¸cão faremos uma revisão da abordagem proposta por “Morabito, Arenales e Arcaro (1992)” [4] na qual foi usada a estratégia da cria¸cão de um grafo And-Or, onde cada nó representa um subproblema e cada aresta a rela¸cão entre esses nós. É poss´ıvel definir o problema como uma busca, especificando o nó inicial, os nós finais e as regras que definem os movimentos legais.

No Problema do Corte Bidimensional Guilhotinado a placa retangular de dimensões (L,W ) é o nó inicial, as pe¸cas menores de tamanho (li,wi) são os nós finais e as arestas

representam os cortes de guilhotina que s˜ao definidos como os movimentos legais para obten¸c˜ao daquelas pe¸cas menores a partir de uma placa maior.

Em um grafo And-Or podemos representar a placa a ser cortada como um nó pai, que pode ter mais de um corte guilhotinado feito em cima dela, e que após aquele corte, sempre será dividida em duas outras novas placas, que por sua vez será feito a mesma coisa até que se encontre a pe¸ca desejada no problema com os cortes feito em cima da pe¸cas. Na figura 3.3 podemos ver nós OU (OR), que são aqueles que a partir de uma placa, tem-se arestas de sa´ıdas que representam os cortes que podem ser feitos em cima daquela em cima daquela placa. Por exemplo: a placa “A” pode ter suas arestas de sa´ıda para “B” OU “C”, caso a aresta que leva a “B” seja escolhida, o corte que será feito será “b” ( vertical). Caso seja “C”, será “c” (horizontal).

(36)

Figura 3.3: Exemplo de n´os OU - Grafo And-Or .

Na figura 3.4 podemos ver os nós E (AND), que representam que sempre após receber um corte guilhotinado, a placa irá se dividir em duas novas placas, que por sua vez poderá ser feitos novos padrões de cortes e que se repetira o processo até não poder ser mais dividida ou encontrar a pe¸ca desejada. Por exemplo : ao ser feito o corte guilhotinado “a” na placa “A” ela será dividida em “B” E “C”, por isso suas arestas de saidas para as

duas. Do mesmo jeito o corte “c” dividi a placa em “D” e res´ıduo.

Figura 3.4: Exemplo de n´os E - Grafo And-Or .

Um subgrafo solu¸cão através do grafo, do nó inicial até os nós finais, representam os padrões de corte que devem ser feitos nas placas para obten¸cão da solu¸cão do problema. Abaixo na figura 3.5 podemos ver uma imagem ilustrativa onde a placa P é mostrada

(37)

no item (a), as pe¸cas que queremos obter no item (b) e as pe¸cas obtidas atrav´es do corte Guilhotinado ilustradas no item (c).

Figura 3.5: (a) Placa. (b) Pe¸cas. (c) Pe¸cas obtidas. .

Na figura 3.6 podemos ver o subgrafo solu¸c˜ao em vermelho onde encontramos a solu¸c˜ao para o problema obtendo as pe¸cas 3,4,5 e 7. Assim como no item (c) da figura 3.5.

Figura 3.6: Exemplo Grafo And-Or e o caminho com a solu¸c˜ao. .

(38)

Na abordagem de “Morabito, Arenales e Arcaro (1992)” [4] , os grafos And-Or na verdade são árvores que ilustram a árvore de recorrência do algoritmo proposto. Assim sendo, é feito uma constru¸cão implicita dessa árvore And-Or e ao mesmo tempo o pro-cedimento Top-Down proposto decide recursivamente se para um dado nó, iniciando a partir de uma ra´ız que representa a placa P, “vale a pena”continuar na busca ou não. Os nós que serão expandidos e continuarão no processo são chamados de nós abertos, já os nós que não continuarão no procedimento e, consequentemente os seus filhos também não serão, são chamados de nós fechados.

Para cada n´o que representa uma placa Rpq(p,q) faremos um procedimento para

descobrir, se devemos considerá-lo como nó aberto ou fechado, isto é, ele e seus filhos devem continuar na busca ou não.

• Devemos descobrir um limite inferior referente a cada subplaca analisada, ou seja, a solu¸cão ótima para essa subplaca está acima desse limite encontrado. O limite inferior utilizado é obtido pela fórmula abaixo:

δ(p,q) = max{π ∗ [p/li] ∗ [q/wi], i ∈ Rpq}

A fórmula tem como o resultado o máximo de pe¸cas com maior valor utilitário de um mesmo tipo, que a placa (p,q) pode dar, pois é uma solu¸cão viável para Rpq.

Figura 3.7: Limite inferior na estrat´egia de Grafo And-Or para resolu¸c˜ao do Problema do Corte Bidimensional Guilhotinado.

(39)

O limite inferior de qualquer nó (p,q) sempre é atualizado quando os nós sucessores fornecerem melhores padrões de corte, assim sendo, se δ(r,q) + δ(p − r,q) > δ(p,q), entao δ(p,q) será substitu´ıdo por δ(r,q) + δ(p − r,q), ou seja, o limite inferior das duas novas placas obtidas por uma padrão de corte.

• O limite superior referente ao n´o pode ser encontrado a partir do problema relaxado para Rpq. µ(p,q) = max X i∈Rpq πi∗ ai s.t. X i∈Rpq (li∗ wi) ∗ ai ≤ (p ∗ q) 0 ≤ ai, i ∈ Rpq.

Podemos notar pela fórmula acima que todos os factivéis padrões de cortes na placa (p,q) precisam seguir as restri¸cões de que as pe¸cas cortadas precisam ser menor ou igual ao retângulo (p,q), esta condi¸cão é imposta pelo inteiro ai que provém o limite superior

para o problema relaxado, ou seja, agora o espa¸co é unidimensional, as pe¸cas poderiam ser “dobradas”suas estruturas, e ainda sim poderiam caber em um espa¸co, que em duas dimensões não conseguiriam. Consideram-se apenas o espa¸co que ela ocupa e não as dimensões. Assim sendo o problema relaxado se torna o Problema da Mochila estudado no cap´ıtulo 2, sessão 2.5.

Para cada nó iriamos necessitar executar uma programa¸cão linear na fórmula des-crita acima, e descobrir o limite superior do mesmo. Mas como podem existir milhares de nós a serem examinadas e rodar uma programa¸cão linear em cada uma delas teria um alto custo, é adotada uma solu¸cão mais relaxada do problema, onde agora o problema permite números reais, isto é, não existe mais o inteiro ai que restringe o problema a

pe¸cas inteiras.

Assim, atrav´es da formula abaixo podemos obter o limite superior desejado.

(40)

Como podemos ver na f´ormula acima, p ∗ q ∗ (πi/li ∗ wi) = (p ∗ q/li ∗ wi) ∗ πi,

onde podemos inferir que agora como o problema aceita números reais, o resultado será o máximo de pe¸cas com maior valor utilitário de um mesmo tipo poss´ıvel assim como no limite inferior. A diferen¸ca entre os dois, é que agora podemos considerar a menor parte de lucro por unidade de aréa da pe¸ca que tiver o maior valor utilitário em πi/li∗ wi.

Assim, no caso onde o corte teria res´ıduo, agora será preenchido com esse valor unitário já que no problema relaxado aceitam-se números reais.

• Agora que possu´ımos o limite inferior e limite superior podemos verificar se um ramo do grafo pode ser descartado, ou seja, um nó irá se tornar fechado. Assim sendo, se µ(r,q) + µ(p − r,q) ≤ δ(p,q) ?, então o corte em r pode ser descartado sem perder a solu¸cão ótima, uma vez que o melhor padrão para os nós (r,q) e (p − r,q) não podem ser melhor do que já sabemos para (p,q).

Figura 3.8: Verifica¸cão de corte na estratégia de Grafo And-Or para resolu¸cão do Problema do Corte Bidimensional Guilhotinado.

(41)

Cap´ıtulo 4

Um algoritmo pseudo-polinomial

Nesta se¸cão iremos apresentar a principal contribui¸cão deste trabalho, isto é, um novo algoritmo para o problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas cujo tempo de execu¸cão é pseudo-polinomial com rela¸cão ao tamanho da entrada. Na solu¸cão proposta por esta monografia para o problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas, iremos considerar assim como no problema estudado no cap´ıtulo anterior, que o valor utilidade de cada objeto pi é igual a área do objeto, ou

seja, devemos maximizar o valor utilidade ou minimizar o desperd´ıcio de material. Para o estudo e solu¸cão do problema, iremos considerar a constru¸cão de um grafo And-Or ac´ıclico dirigido, isto é, suas arestas tem dire¸cão e não formam ciclos direcionados no grafo. A constru¸cão será usada para melhor visualiza¸cão do problema e entendimento do algoritmo proposto.

Primeiramente, a partir da placa inicial (L,W ), iremos gerar os vértices do grafo, fazendo o produto cartesiano entre os intervalos fechados [1,L] e [1,W ]. Assim os vértices do grafo representarão elementos do produto cartesiano de [1,L] e [1,W ]. Assim temos o conjunto de todos os pares ordenados para os vertices que são as representa¸cões das pe¸cas (li,wi) que podemos obter através de um padrão de corte em (L,W ).

Iremos considerar a seguinte regra para reduzir o número de pe¸cas/vértices do problema: pe¸cas iguais mas com as dimensões invertidas, são consideradas a mesma pe¸ca, por exemplo p1 = (1,2) e p2 = (2,1) serão representadas por um único nó. Tal regra é

segura pois para obtermos a pe¸ca desejada no mundo real, bastaria rotacion´a-la. Assim temos.

(42)

As arestas são as representa¸cões dos cortes de uma pe¸ca, onde a dire¸cão da aresta significa que a partir de uma pe¸ca obtemos a outra. Por exemplo: p1 = (3,2) → p2 = (2,2)

representa que a partir da pe¸ca 1, fazendo um corte vertical, obtemos a pe¸ca 2. Caso uma pe¸ca se divida em duas de dimens˜oes iguais, teremos duas arestas de sa´ıda de um v´ertice para o outro. Veja na Figura 4.1.

(a) Corte que resulta em duas pe¸cas diferentes

(b) Corte que resulta em duas pe¸cas iguais

Figura 4.1: Exemplo da transforma¸cão do problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas para grafo: em (a) podemos ver um vértice 3,2 tendo duas arestas de sa´ıdas apontando para outros dois vértices (2,2) e (1,2) que equivale ao padrão de corte ao seu lado , em (b) podemos ver um vértice (4,4) tendo duas arestas de sa´ıda apontando para o vértice (2,2) que equivale ao padrão de corte ao seu lado.

As arestas serão geradas a partir das seguintes regras: Defini¸cão 5. Se (li,wi) não é uma das pe¸cas que queremos obter:

E se (li = lj E wi > wj) OU (li > lj E wi = wj):

(43)

As regras acimas levam em considera¸cão que se o vértice já é uma das pe¸cas que queremos obter, não é necessário criar uma aresta de sa´ıda a partir deste, uma vez que ela já é o que estamos buscando e se fizermos mais cortes não haveria ganho nenhum pois sua área já é a desejada e seu valor utilidade não irá aumentar se houver mais cortes. As arestas só são geradas a partir de uma pe¸ca maior em dire¸cão a uma pe¸ca menor, mantendo sempre uma dimensão da mesma, pois só podem ser feito um corte guilhotinado por vez, sendo ele vertical ou horizontal.

Uma considera¸cão importante é o caso em que a pe¸ca obtida por um corte, quebra a regra li ≥ wi∀ pi. Caso isso aconte¸ca, basta fazer a inversão da pe¸ca, deixando impl´ıcito

que houve um rotacionamento na dimens˜ao da pe¸ca.

Figura 4.2: Exemplo de transforma¸cão impl´ıcita do problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas para grafo.

.

Uma vez obtido o grafo com as regras acima, podemos perceber que todo o al-goritmo e regras criadas apenas estruturam vértices do tipo Or , mas para a solu¸cão do problema precisaremos da cria¸cão de vértices And, mesmo que na estrutura já criada os vértices And estejam implicitamente estruturado.

Os vértices And em nosso contexto devem representar pares de placas que são geradas a partir de um único corte. Assim sendo, para se criar todos os vértices And usaremos os vértices que já foram criados. Podemos seguir os passos abaixo para todos os nós do grafo:

(44)

Passo 1 - Dado um n´o “v” verificamos cada aresta de entrada “e” que chega neste v´ertice.

Passo 2 - A partir desta aresta “e”, descobrimos a pe¸ca pai que gerou “v”.

Passo 3 - A partir da pe¸ca pai, descobrimos a pe¸ca complementar da pe¸ca “e”, denominado “e2”.

Passo 4 - Criar um nó com os mesmos atributos que o nó pai, com arestas de sa´ıda apontando para as sa´ıdas de “e”,“e2”. E uma aresta de entrada vindo do antigo nó pai.

Passo 5 - Remover as arestas “e”,“e2”. Podemos ver um exemplo na Figura 4.3:

Figura 4.3: Exemplo de transforma¸cão para grafo And-Or do problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas.

.

Neste ponto, cada padr˜ao de corte poss´ıvel de ser obtido para P pode ser visualizado no grafo And-Or constru´ıdo como um subgrafo, denotado como subgrafo solu¸c˜ao, definido da seguinte forma:

• O v´ertice representando (L,W ) pertence ao subgrafo;

• Um v´ertice Or que pertence ao subgrafo possui exatamente 1 aresta de sa´ıda neste subgrafo.

(45)

• Um v´ertice And que pertence ao subgrafo possui todas suas arestas de sa´ıda neste subgrafo.

Desta forma, para solucionar o problema devemos achar o melhor subgrafo solu¸cão, isto é, o subgrafo que representa o padrão de corte que maximiza o valor utilidade.

Nosso algoritmo primeiramente irá gerar uma ordena¸cão topológica dos vértices do grafo And-Or criado.

Uma ordena¸cão topológica consiste em ordenar os vértices de um grafo ac´ıclico dirigido G=(V,E) de forma que, se existe um caminho do vértice v para o vértice u, então v aparece antes de u na ordena¸cão [19].

Figura 4.4: Exemplo de Ordena¸c˜ao Topol´ogica .

Para exemplificar e ilustrar o passo a passo do nosso algoritmo, escolhemos uma placa inicial (3,3) e queremos obter o melhor padr˜ao de corte que maximize o valor utili-dade das pe¸cas que desejamos obter, sendo elas p1 = (2,1) e p2 = (3,1). Na Figura 4.5,

podemos ver a estrutura do grafo preliminar montado, sem os n´os AND. A Figura 4.6 ilustra o grafo And-Or completo.

(46)

Figura 4.5: Exemplo de uma placa 3x3 para um grafo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas.

.

Assim sendo, a partir do grafo And-Or criado na Figura 4.6 faremos uma ordena¸cão topológica. Assumiremos uma ordena¸cão dos vértices de forma decrescente com rela¸cão a área das placas que representam. Podemos ver na Figura 4.7 o grafo ordenado, onde representamos em cada nó a sua largura, altura, área, e o tipo de nó ( And ou Or) como atributos, acima de cada representa¸cão.

O algoritmo é do tipo bottom-up, onde para todo nó ( a partir do primeiro nó da ordena¸cão até o último, em ordem crescente), devemos calcular o valor utilidade do nó corrente a partir dos valores dos nós filhos.

(47)

Figura 4.6: Exemplo de uma placa 3x3 para um grafo And-Or -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas.

. Segue abaixo o algoritmo:

A l g o r i t m o bottom−up ( n´os do grafo ) {

Para todo nó, ordenados de forma crescente em rela¸cão à area fa¸ca{ Crie uma variavel auxiliar contador

(contabilizará a melhor área/utilidade acumulada para o nó corrente)

Se o n´o n˜ao tiver arestas de sa´ıda {

auxiliar = área / utilidade do nó corrente } Senão{

(48)

Cada aresta de sa´ıda do nó levará a algum nó que

já teve sua variável auxiliar já calculada. Logosome os valores de todas as variáveis auxiliares desses nós, e atribua

essa soma a vari´avel auxiliar do n´o corrente. }

Se o n´o for do tipo Or {

Cada aresta de sa´ıda do nó que levará a algum nó que já teve sua variável auxiliar calculada, atribua o maior valor dentre as variáveis auxiliares

`

a variavel auxiliar do n´o corrente. }

} } }

Figura 4.7: Exemplo de uma placa 3x3 para um grafo And-Or ordenado topológicamente -problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas.

.

(49)

Figura 4.8: Passo 1 - Algoritmo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas.

.

Figura 4.9: Passo 2 - Algoritmo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhotinados em Placas.

(50)

Figura 4.10: Passo 3 - Algoritmo -problema de Gera¸c˜ao de Padr˜oes de Cortes Guilhoti-nados em Placas.

.

(51)

(52)

.

(53)

.

Para descobrir o subgrafo solu¸cão que produz a melhor solu¸cão (padrão de corte), basta marcar quais nós (valor da variável auxiliar) foram escolhido através da escolha do maior valor para descobrir o valor de cada nó OR. Assim, após o algoritmo ter sido feito, teremos nos marcadores quais os nós devemos seguir e qual é o subgrafo solu¸cão (padrão de corte) da placa P = (L,W )

(54)

Figura 4.17: Subgrafo Solu¸cão - Algoritmo -problema de Gera¸cão de Padrões de Cortes Guilhotinados em Placas.

.

4.1 Prova do algoritmo Pseudo-Polinomial

4.1.1 O tempo de execu¸

c˜

ao do algoritmo

A partir de um grafo And-Or G com n vértices e m arestas, nosso algoritmo efetua O(n + m) passos, isto é, número linear de passos com rela¸cão ao número de vértices e arestas do grafo G que constru´ımos.

Para verficar tal afirma¸cão basta observar que uma ordena¸cão topológica pode ser constru´ıda em tempo O(n + m) [20]. Além disso, no algoritmo bottom-up criado no presente trabalho, percorremos todos os nós do grafo de acordo com a ordem topológica dada, visitando suas arestas de entrada (cada aresta de G é visitada exatamente uma vez), calculando assim os pesos de cada vértice. Dessa forma podemos concluir que o algoritmo possui complexidade O(n + m), pois para cada nó, devemos percorrer todas arestas que chegam nele e fazer opera¸cões constantes, como saber o máximo (Or) ou fazer a soma dos pesos das arestas (And), para assim podermos passar para o próximo nó que está ordenado topologicamente.

Logo, temos

|V (G)|

X

i=1

(dv−+ 1) = m + n.

(55)

4.1.2 O tempo de execu¸

c˜

ao da cria¸

c˜

ao do grafo

Dado o grafo And-Or G, o tempo de execu¸cão do nosso algoritmo é linear com rela-¸cão ao número de vértices e arestas de G. Sendo assim, devemos verificar o algoritmo para constru¸cão de G e seu tempo de execu¸cão. Dado uma placa inicial (L,W ) primeiramente criamos os nós Or da seguinte forma:

A l g o r i t m o cria¸cão nó s Or ( L,W ) { Para i:=1 até L fa¸ca{

Para j:=i at´e W fa¸ca{ cria o n´o (i,j) }

} }

Assim temos que o procedimento acima demanda tempo O (L x W) e produz O (L x W) vértices Or. Após a cria¸cão dos nós Or, iremos criar os nós And e as arestas do grafo conforme o algoritmo abaixo (a Figura 4.18 ilustra a cria¸cão):

A l g o r i t m o cria¸cão dos And e das arestas ( nós do grafo ) { Para cada nó v (i,j) que não é uma pe¸ca final desejada fa¸ca{

Para l:=1 at´e bj₂c fa¸ca{

cria um n´o al representando o corte [i:l , i:(j-l)];

cria uma aresta de v para al;

cria uma aresta de al para os n´os que representam (i,l) e (i,j-l);

}

Para k:=1 at´e b₂icfa¸ca{

cria um n´o bk representando o corte [(i-k):j , k:j];

cria uma aresta de v para bk;

cria uma aresta de bk para os n´os que representam (k,j) e (i-k,j);

} } }

Como podemos observar o tempo de execu¸cão da segunda etapa do algoritmo possui rela¸cão direta com o número de nós And que ele irá criar, pois para cada nó And

(56)

Figura 4.18: Cria¸cão do grafo And-Or - Etapa de cria¸cão dos nós And e arestas. .

criado é efetuado um número constante de opera¸cões como cria¸cão de arestas e vértices. Logo conclu´ımos que essa etapa de cria¸cão possui tempo linear com rela¸cão ao número de vertices And criados.

4.2 O tamanho do grafo

As duas se¸cões anteriores mostram que o tempo de execu¸cão do algoritmo como um todo é linear com rela¸cão ao grafo constru´ıdo. No entanto, o grafo não faz parte da entrada, e portanto, devemos determinar o tamanho do grafo em fun¸cão da dimensão da placa de entrada P .

Sabemos que o n´umero de arestas em um grafo completo ´e (n2_{− 2)/2 sendo n o}

número de vértices [21], dessa forma, no pior caso, o limite superior para o número de arestas será da ordem de n2 _v´_ertices.

Primeiramente iremos observar o número de nós no grafo sem os vértices AND. Como cada OR é um retângulo distinto, sua largura e altura são inteiros (li,wi) e elas

tem que ser menor que a altura e largura (L,W ) da placa P . Assim podemos concluir, que o número de nós Or não pode ultrapassar o produto (L × W ). No entanto, o número exato de vértices Or que temos é L x W −(W2− W )/2, onde o primeiro termo 00_{L x W ”}

é equivalente a todos os nós da placa P , e a subtra¸cão pelo segundo termo (W2_{− W )/2}

são os nós que não serão considerados, pelo fato de que placas que tem altura e largura equivalente a outra placa, apenas com uma inversão de eixos, não são consideradas na

(57)

solu¸c˜ao proposta, por exemplo p1 = 1,2 e p2 = 2,1 s˜ao consideradas equivalentes. Assim,

concluimos que o número de vértices Or é L x W −(W2)/2 e está na ordem de O (L x W). Veja a Figura 4.19.

Figura 4.19: ´Area considerada para criar as pe¸cas. .

Podemos determinar que o número de nós é polinomial em fun¸cão da altura e largura da placa P , logo pelo teorema em que o número de arestas é igual a (n2 _{− 2)/2,}

conclu´ımos que o número de arestas também é polinomial em rela¸cão a P . Para uma pe¸ca l’,w’ temos l’-1 cortes verticais e w’-1 cortes horizontais. Assim podemos inferir que o número de arestas no grafo Or, isto é, grafo sem contar os nós And, é descrito pela formula: |E(Gor)| = L X l0₌₁ W X w0₌₁ (l0+ w0− 2) |E(Gor)| = L X l0₌₁ [( W X w0₌₁ w0) + W (l0− 2)] |E(Gor)| = L X l0₌₁ ((W + 1)W 2 + W (l 0_{− 2))} |E(Gor)| ≤ (L(W + 1)W 2 ) + W L X l0₌₁ l0 |E(Gor)| ≤ L(W + 1)W 2 + W (L + 1)L 2

Sendo assim, conclu´ımos que o n´umero de arestas do grafo Or est´a na ordem de O(L × W2_{+ W × L}2_).

(58)

Pela constru¸cão do grafo, sabemos que o número de vértices And do grafo And-Or é aproximadamente o número de arestas do grafo Or divido por 2, assim temos:

|V (GAnd−Or)| = O(L × W2+ W × L2).

Como o número de arestas do Grafo And-Or é 3 vezes o número de nós And (Veja a Figura 4.20). Temos:

|E(GAnd−Or)| = O(L × W2+ W × L2).

Figura 4.20: Grafo Or transformado para And-Or. .

Como o eixo L é sempre maior que o W , podemos inferir que o número de vertices e arestas do grafo é da ordem de O(L2 x W ).

Finalmente, a complexidade total do nosso algoritmo ser´a O(|V (G)| + |E(G)|) = O(L2× W ).

Assim, temos um algoritmo pseudo-polinomial para o problema, como descrito na Se¸c˜ao 2.3.

(59)

Cap´ıtulo 5

Conclus˜

ao

O uso de grafos And-Or e o estudo sobre o seu uso no problema Gera¸cão de Cortes Guilhotinados em Placas, permitiram a cria¸cão de um algoritmo Pseudo-Polinomial para a resolu¸cão do problema não-restrito. A solu¸cão proposta usa a técnica de programa¸cão dinâmica onde um grafo And-OR é utilizado como estrutura de dados ao invés de uma matriz. Essa abordagem nos proporciona um estratégia para percorrer os nós do grafo encontrando uma solu¸cão ótima do problema.

´

E importante ressaltar que a abordagem proposta para produ¸cão de um algoritmo pseudo-polinomial para o problema é nova, e o algoritmo proposto neste trabalho possui complexidadade assintótica equivalente ao estado da arte para o problema.

O problema solucionado considera as restri¸cões mais básicas, onde o tamanho dos eixos são inteiros, o valor utilidade de cada pe¸ca é igual a sua área, o número de cortes que podem ser feitos é ilimitado, e não há limita¸cão quanto ao número máximo e m´ınimo de pe¸cas a serem obtidas com uma determinada dimensão.

Como trabalhos futuros, pretendemos considerar outras varia¸cões do problema, ampliando a aplicabilidade de nossa abordagem no mundo real. Uma análise emp´ırica comparando nossa abordagem com as demais solu¸cões para o problema, também será realizada no futuro.

(60)

Referˆ

encias Bibliogr´

aficas

[1] P. Gilmore and R. E. Gomory, “Multistage cutting stock problems of two and more dimensions,” Operations research, vol. 13, no. 1, pp. 94–120, 1964.

[2] J. Herz, “Recursive computational procedure for two-dimensional stock cutting,” IBM Journal of Research and Development, vol. 16, no. 5, pp. 462–469, 1972.

[3] J. Beasley, “Algorithms for unconstrained two-dimensional guillotine cutting,” Jour-nal of the OperatioJour-nal Research Society, pp. 297–306, 1985.

[4] R. Morabito, M. Arenales, and V. Arcaro, “An and—or-graph approach for two-dimensional cutting problems,” European Journal of Operational Research, vol. 58, no. 2, pp. 263–271, 1992.

[5] R. Silveira and R. Morabito, “Um método heur´ıstico baseado em programa¸cão di-nâmica para o problema de corte bidimensional guilhotinado restrito,” Gestão & Produ¸cão, vol. 9, no. 1, pp. 78–92, 2002.

[6] C. M. Da Bianco and A. D. da Silva, “Problema de corte bidimensional guilhotinado-uma abordagem atrav´es de ferramentas cad e heur´ısticas de posicionamento.” XXX Encontro Nacional de Engenharia de Produ¸c˜ao.

[7] J. L. Szwarcfiter and L. Markenzon, Estruturas de Dados e seus Algoritmos. Livros T´ecnicos e Cient´ıficos, 1994, vol. 2.

[8] L. Bueno, “Teoria da complexidade computacional,”

http://professor.ufabc.edu.br/ leticia.bueno/classes/aa/materiais/complexidade2.pdf, acessado em 2017.

[9] S. W. Song, “Complexidade de algoritmos,” https://www.ime.usp.br/˜song/ mac5710/slides/01complex.pdf, acessado em 2017.