HEURÍSTICAS GRASP PARA A MINIMIZAÇÃO DO ATRASO TOTAL NO PROBLEMA DE PROGRAMAÇÃO DE TAREFAS EM UMA MÁQUINA COM SETUP TIME

HEURÍSTICAS GRASP PARA A MINIMIZAÇÃO DO ATRASO TOTAL NO PROBLEMA DE PROGRAMAÇÃO DE TAREFAS EM UMA MÁQUINA COM SETUP TIME Gilberto Vinícius P. Nunes Departamento de Informática, Universidade Federal de Viçosa Campus Universitário da UFV, 36570-000 Centro Viçosa, MG, BRASIL gilbertovinicius@dpi.ufv.br José Elias C. Arroyo Departamento de Informática, Universidade Federal de Viçosa Campus Universitário da UFV, 36570-000 Centro Viçosa, MG, BRASIL jarroyo@dpi.ufv.br RESUMO Neste artigo é considerado o problema de programação de tarefas em uma máquina com tempos de preparação dependentes da seqüência com o objetivo de minimizar o atraso total das tarefas com relação a suas datas de entrega. São desenvolvidas duas heurísticas GRASP (Greedy Randomized Adaptive Search Procedure) que usam as heurísticas VNS e VND na fase de busca local e a heurística ILS (Iterated Local Search) como um procedimento de pós-otimização. As heurísticas híbridas são comparadas com um algoritmo GRASP proposto na literatura que provou ser melhor que outros algoritmos propostos também na literatura. Testes computacionais, sobre um conjunto de problemas com até 85 tarefas, mostram que as heurísticas propostas são eficientes e competitivas. PALAVRAS CHAVE. Programação de tarefas, heurísticas, GRASP, Otimização combinatória. Área principal: Metaheurísticas ABSTRACT In this paper the problem of scheduling jobs in a single machine with sequence dependent setup times is considered with the objective of minimizing the total tardiness with respect to the due dates. We develop two GRASP (Greedy Randomized Adaptive Search Procedure) heuristics that use the NVNS and VND heuristic as a local search mechanism and ILS (Iterated Local Search) heuristic as a post-optimization procedure. The proposed hybrid heuristics are compared with a GRASP algorithm proposed in the literature that it is better than other algorithms from the literature. Computational tests on a set of test problems involving up to 85 jobs, show that our heuristics are efficient and competitive. KEYWORDS. Job scheduling, Heuristics, GRASP, Combinatorial optimization. Main area: Metaheuristics 1332

1. Introdução Neste artigo é abordado o problema de Programação de Tarefas em uma Máquina simples com tempos de preparação (Setup Time) dependentes da seqüência. Este problema é denotado por PTMST. O objetivo do problema é minimizar o atraso total das tarefas com relação a suas datas de entrega. Neste problema, a partir de um tempo zero, um conjunto de n tarefas deve ser processado em uma máquina disponível continuamente. Cada tarefa j possui um tempo de processamento p j e uma data de entrega d j. Se duas tarefas i e j são processadas consecutivamente, existe um tempo de preparação (setup time) S ij entre o tempo de finalização do processamento da tarefa i e o início do processamento da tarefa j. Em geral, S ij S ji. Quando uma tarefa j é a primeira a ser processada, um tempo de preparação inicial S 0j é considerado, ou seja, uma tarefa fictícia 0 é incluída. Considere uma seqüência de tarefas (1, 2,, i,, n), onde i denota a tarefa na posição i. O problema PTMST, considerado neste trabalho, consiste em determinar a permutação de n tarefas que minimize o atraso total definido por: n T = i= 1 Ti, n onde T i = maxk = 1 { Ck dk, 0} é o atraso da tarefa i e Ci = = ( S k k k + p 1 1, k ) representa o tempo de finalização da tarefa i. A maioria dos trabalhos sobre problemas de programação de tarefas em máquinas não consideram tempos de preparação (setup times) dependentes da seqüência. Nas revisões bibliográficas de Allahverdi et al. (1999) e Allahverdi et al. (2008) percebe-se que tempos de preparação são muito importantes na maioria das situações práticas e devem ser considerados no desenvolvimento de algoritmos para este tipo de problema. No problema PTMST têm sido considerados vários critérios de decisão que são conflitantes. Os principais critérios são: i) minimização do tempo de finalização do processamento da todas as tarefas (makespan), ii) minimização do tempo de permanência das tarefas no sistema (tempo de fluxo), iii) minimização de atrasos na execução das tarefas com relação a suas datas de entrega (por exemplo, atraso máximo ou atraso total). O critério i) esta relacionado com a utilização eficiente das máquinas. O critério ii) está associado ao nível de estoque em processamento (work - in - process). O critério iii) estabelece uma política da programação da produção que procura atender a ordem do cliente na data de entrega determinada. Critérios de decisão envolvendo datas de entrega são de grande importância nos sistemas de manufatura, pois pode existir uma série de custos quando uma tarefa é entregue com atraso. Dentre estes custos podem-se citar penalidades contratuais, perda de credibilidade e danos na reputação da empresa que poderão afastar outros clientes (Sen e Gupta,1984). O problema PTMST com minimização do atraso total é um problema NP-Difícil, como mostrado em Du e Leung (1990) e é abordado em vários trabalhos (Allahverdi et al., 2008). Ragatz (1993) propõe um algoritmo exato baseado na técnica Branch-and-Bound (B&B). Tan e Narashimha (1997) propuseram uma heurística Simulated Annealing (AS) que mostrou ser mais eficiente que outras heurísticas propostas anteriormente. Diferentes versões de algoritmos genéticos foram propostas por Rubin e Ragatz (1995), Armentano e Mazzini (2000) e França et al. (2001). Rubin e Ragatz (1995), também propõem uma heurística de busca local com múltiplos reinícios (Random Multi Start Local Search - RMSLS) e geram um conjunto de 32 problemas testes com 15, 25, 35 e 45 tarefas. Tan et al. (2000), utilizando os problemas testes de Rubin e Ragatz, analisam o desempenho de quatro métodos diferentes: B&B de Ragatz (1993), SA de Tan e Narashimha (1997) e os métodos algoritmo genético e RMSLS de Rubin e Ragatz (1995). As conclusões de Tan et al. (2000) indicam que as heurísticas SA e RMSLS geram os melhores resultados, especialmente para problemas envolvendo maior número de tarefas. Vale ressaltar que o algoritmo exato B&B de Ragatz (1993) gera soluções aproximadas (limites superiores) com relação às soluções ótimas, devido à execução do algoritmo ser limitada a um número máximo de operações (exploração de dois milhões de nós). Gagne et al. (2002) desenvolveram uma heurística baseada em otimização por colônia de formigas (Ant Colony Optimization), denotada por ACO. A heurística ACO foi comparada i 1333

com os melhores resultados obtidos por Tan et al. (2000) e mostrou ser bastante competitiva e rápida computacionalmente. Uma vantagem da heurística ACO é que ela apresenta soluções de melhor qualidade para problemas com maior número de tarefas (35 e 45 tarefas). Gagne et al. (2002) também testam a heurística ACO em outro conjunto de 32 problemas de maior dimensão gerados pelos mesmos autores. Este conjunto de problemas foi dividido em grupos de 55, 65, 75 e 85 tarefas e os resultados da heurística ACO para estas instâncias foram disponibilizados. Recentemente, Gupta e Smith (2006) propuseram duas heurísticas diferentes: GRASP- PR (GRASP com Path Relinking) e PSLS (Problem Space-based Local Search). Eles mostraram que a heurística PSLS é bastante competitiva quando comparada com a heurística ACO de Gagne et al. (2002) e, além disso, mostrou ser mais rápida computacionalmente nesta mesma comparação. Os autores também mostraram que a heurística GRASP é bastante superior à heurística ACO. A desvantagem da heurística GRASP em relação à ACO é o consumo de um tempo computacional mais alto. Neste artigo são propostas duas heurísticas GRASP híbridas nas quais são utilizadas as heurísticas VNS (Variable Neighborhood Search) e VND (Variable Neighborhood Descent) na fase de busca local. Nas heurísticas, também é testado um procedimento de pós-otimização baseado na heurística Iterated Local Search (Lourenço et al., 2003). O objetivo da pósotimização é melhorar a melhor solução obtida pelo algoritmo GRASP. O desempenho dos algoritmos híbridos é avaliado através da comparação com a heurística GRASP proposta por Gupta e Smith (2006). No algoritmo GRASP de Gupta e Smith (2006) também é usado um procedimento de pós-otimização baseado na técnica path-relinking (Laguna e Martí,1999) que consiste em explorar trajetórias que conectem duas soluções de elite, a primeira denominada origem e a segunda denominada guia. As heurísticas desenvolvidas neste trabalho são testadas utilizando os conjuntos de problemas gerados por Rubin-Ragatz (1995) e Gagne et al. (2002). Estes problemas são disponibilizados na Internet e foram usados por vários pesquisadores na avaliação de algoritmos para o problema PTMST. Este artigo é organizado da seguinte maneira. Na Seção 2 são apresentados os detalhes da implementação das heurísticas híbridas propostas. Os testes realizados e os resultados computacionais são mostrados na Seção 3. A Seção 4 apresenta as conclusões do trabalho. 2. Algoritmos Híbridos Propostos GRASP, proposto por Feo e Resende (1995), é um algoritmo heurístico de múltiplas partidas, na qual cada iteração consiste de duas fases: construção e busca local. A primeira fase constrói uma solução s 1 viável utilizando um algoritmo guloso aleatório. Na segunda fase a solução construída s 1 é melhorada através de um método de busca local ou busca em vizinhança. A melhor solução obtida s*, durante todas as iterações GRASP, é retornada. Na Figura 1 apresenta-se um pseudocódigo da heurística GRASP básica. A heurística GRASP tem sido aplicada para resolver diversos problemas de otimização combinatória mostrando ser bastante eficiente (Festa e Resende, 2004). Procedimento GRASP ( I max, α) 1. f(s*) (infinito); 2. para i 1 até I max faça 3. s 1 ConstruçãoGulosaAleatória(α); 4. s 2 BuscaLocal(s 1 ); 5. se f(s 2 ) < f(s*) então 6. s* s 2 ; 7. fim para 8. Retorne s*; fim GRASP Figura 1. GRASP básico. 1334

A heurística GRASP possui como entrada dois parâmetros: I max (número de iterações) e α (taxa de aleatoriedade da fase construtiva). Nas subseções seguintes, são detalhadas as etapas de construção e busca local da heurística GRASP aplicada para resolver o problema PTMST no qual é minimizado o atraso total das tarefas. 2.1. Construção Gulosa Aleatória Nesta etapa é construída uma solução inicial utilizando uma estratégia gulosa com uma taxa de aleatoriedade α [0,1]. Uma seqüência de tarefas (solução) deve ser construída inserindo uma tarefa por vez numa seqüência parcial s. Como estratégia gulosa é utilizada a regra de despacho proposta por Gupta e Smith (2006) para minimizar o atraso das tarefas no problema PTMST. Esta regra consiste em ordenar as tarefas de acordo com a seguinte função de custo: Custo(j) = {d j (C k + p j )}(p j + S kj ), onde, d j e p j são, respectivamente, a data de entrega e o tempo de processamento da tarefa j candidata para ser inserida na seqüência parcial s. C k é o tempo de finalização da última tarefa k da seqüência parcial e S kj é o setup time produzido pelas tarefas k e j. Se a tarefa j fosse inserida na seqüência s, tem-se s = {1,...,k}+{j} = {1,...,k, j}. Gupta e Smith (2006) observaram que a função de custo proposta por eles apresentou um melhor desempenho que a função ATCS (Apparent Tardiness Cost with Setups) proposta por Lee et al. (1997), em termos de qualidade de soluções obtidas e tempo computacional. A regra ATCS já foi considerada uma das melhores regras para a minimização de atrasos no problema PTMST. Na construção de uma solução, inicialmente as tarefas são ordenadas em uma lista de candidatos (LC) usando a função de custo de Gupta e Smith (2006). A partir de uma Lista de Candidatos Restrita (LCR), formada pelas LCR primeiras tarefas de LC, seleciona-se aleatoriamente uma tarefa j para ser inserida na seqüência parcial s. Remove-se a tarefa j de LC, reordenam-se as tarefas (utilizando a função de custo) e o processo é repetido escolhendo-se uma nova tarefa j. A construção finaliza quando é obtida uma seqüência completa contendo todas n tarefas. O tamanho da sub-lista LCR depende da taxa de aleatoriedade α utilizada: LCR = max(1, α LC ). Note que, se a taxa α = 0, a escolha da tarefa j é puramente gulosa (escolhe-se sempre a primeira tarefa da lista LC). Se α = 1, a escolha da tarefa j é totalmente aleatória. 2.2. Busca Local A busca local é um procedimento iterativo que consiste em melhorar uma solução s 1 procurando novas soluções vizinhas. Estas soluções vizinhas são obtidas realizando algumas alterações (movimentos) na estrutura da solução atual s 1. Neste trabalho foram testados dois tipos de buscas locais, obtendo duas versões da heurística GRASP: Busca local baseada na heurística VNS Busca local baseada na heurística VND As heurísticas VNS (Variable Neighborhood Search) e VND (Variable Neighborhood Descent) foram recentemente propostas por Mladenovic e Hansen (1997). A idéia principal destas heurísticas é mudar de forma sistemática a estrutura de vizinhança na busca local com o objetivo de procurar soluções de boa qualidade o mais distante da solução inicial, escapando assim de ótimos locais principal deficiência de uma heurística de busca local. Seja {N 1, N 2,... N r } um conjunto de r estruturas de vizinhança predefinidas onde N k (s) é a vizinhança k da solução s. A heurística VNS gera um vizinho s N k (s) da solução corrente s e executa uma busca local a partir desta solução obtendo uma solução ótima local s. Se esta solução s melhora a solução corrente s, o processo reinicia a partir desta solução (i.e. s = s ) e sempre utilizando a primeira estrutura de vizinhança N 1. Caso contrário, a estrutura de vizinhança é alterada de forma sistemática. 1335

A heurística VND seleciona, a cada iteração, o melhor vizinho s da vizinhança atual (s N k (s)). A aceitação desta solução é similar ao VNS, se a solução s melhora a solução corrente s, o processo reinicia a partir desta solução (i.e. s = s ) utilizando também a primeira estrutura de vizinhança N 1. Neste trabalho, as heurísticas VND e VNS foram implementadas com as seguintes estruturas de vizinhança: N 1 : Vizinhança inserção: um vizinho de s 1 é gerado inserindo uma tarefa que está na posição i, em outra posição j da seqüência, 1 i, j n, j i. Usando este movimento é possível gerar (n-1) 2 vizinhos. N 2 : Vizinhança de troca: uma solução vizinha de s 1 é gerada fazendo a troca de duas tarefas i e j da seqüência, 1 i, j n, i j. O número de vizinhos gerados com este movimento é n(n-1)/2. N 3 : Vizinhança 2-OPT: gera-se uma solução vizinha de s 1 escolhendo-se dois pares não consecutivos de tarefas consecutivas, (i, i+1) e (j, j+1), onde 1 i, j < n, j i, e é feita a troca da conectividade entre esses pares de forma que se restabeleça a conectividade da seqüência. Na implementação realizada, o número de vizinhos gerados pela vizinhança 2-OPT é (n-2)(n-1)/2. As Figuras 2 e 3 mostram, respectivamente, os pseudocódigos das heurísticas VNS e VND. Ressalta-se que, na busca local usada no procedimento VNS, é usada a vizinhança inserção e a escolha da próxima solução é baseada no primeiro melhor vizinho, ou seja, a primeira solução vizinha que melhore a solução atual (s) é escolhida para continuar com a busca local. Procedimento VNS(s) //s = solução inicial Inicio 1. k 1; 2. enquanto (k 3) faça 3. Gere, aleatoriamente, um vizinho s N k (s); 4, s BuscaLocalInsercao(s ); 5. se f(s ) < f(s) então 6. s s ; k 1; 7. senão k k + 1; 8. fim-se; 9. fim-enquanto; 10. Retorne s; Fim VNS. Figura 2: Heurística VNS. Procedimento VND(s) //s = solução inicial Inicio 1. k 1; 2. enquanto (k 3) faça 3. Encontre o melhor vizinho s N k (s); 4. se f(s ) < f(s) então 5. s s ; k 1; 6. senão k k + 1; 7. fim-se; 8. fim-enquanto; 9. Retorne s; Fim VND. Figura 3: Heurística VND. 1336

2.3. Pós-Otimização com ILS A heurística Iterated Local Search (ILS) é baseada na idéia de que um procedimento de busca local pode ser melhorado, gerando-se novas soluções de partida, as quais são obtidas por meio de perturbações na solução ótima local. A perturbação deve permitir que a busca local explore diferentes soluções e, além disso, deve evitar um reinício aleatório. O método ILS é, portanto, um método de busca local que procura focar a busca não no espaço completo de soluções, mas em um pequeno subespaço, definido por soluções que são ótimas locais (Lourenço et al., 2003). Na Figura 4 mostra-se os passos da heurística ILS. Procedimento ILS (s*, I ILS ) //s* é a solução inicial 1. para i 1 até I ILS faça 2. s 1 Perturbação(s*); 3. s 2 BuscaLocal(s 1 ); 4. Se f(s 2 ) < f(s*) então 5. s* s 2 ; 6. fim Se. 7. fim para. 8. Retorne s*; fim ILS Figura 4. Heurística ILS. Neste trabalho é utilizada a heurística ILS para melhorar a solução (ótimo local) obtida pela heurística GRASP. Na Figura 5 mostra-se o pseudocódigo da heurística GRASP com ILS. Note que, após a finalização dos passos da heurística GRASP, é executado o procedimento de pós-otimização baseado na heurística Iterated Local Search (ILS). A heurística ILS inicia com a melhor solução s* obtida pelo algoritmo GRASP. Para o problema de seqüenciamento de tarefas considerado neste artigo, a perturbação de uma solução, no ILS, consiste em fazer duas trocas (de tarefas) aleatórias. A primeira troca é feita entre duas tarefas adjacentes e a segunda entre duas tarefas que se encontram a d posições distantes, onde d = max{n/5, n}. Esta idéia de fazer a perturbação foi também usada por Stützle (1998), na solução do problema de programação de tarefas em um sistema flowshop. A solução s 1 obtida pela perturbação é melhorada por uma busca local na qual é usada a vizinhança inserção, obtendo um ótimo local s 2. Este ótimo local é aceito se ele melhorar a melhor solução atual, caso contrário ele é descartado. Os procedimentos de perturbação e melhoria através da busca local são repetidos por um número I ILS de iterações. Procedimento GRASP_ILS (I max, I ILS ) 1. s GRASP(I max ); 2. s* ILS(s, I ILS ); 3. Retorne s*; fim GRASP_ILS. Figura 5. Pseudocódigo GRASP_ILS. 3. Resultados Computacionais Neste trabalho é testado o desempenho de duas versões da heurística GRASP: GRASP com VNS (GRASP-VNS) e GRASP com VND (GRASP-VND). Além disso, em cada uma destas heurísticas é testado o procedimento de pós-otimização usando a heurística ILS. As heurísticas GRASP propostas neste trabalho foram programadas na linguagem C++ e os testes computacionais foram realizadas no ambiente do sistema operacional Linux (kernel 2.6.17) utilizando um computador com processador Pentium IV de 3.0 GHz e com 1 GB de RAM. 1337

O desempenho das heurísticas propostas é comparado entre as próprias heurísticas e também é avaliado através da comparação com outro algoritmo GRASP, proposto recentemente por Gupta e Smith (2006), para o mesmo problema abordado neste trabalho. Vale ressaltar que, a heurística GRASP de Gupta e Smith usa um procedimento de pós-otimização utilizando a técnica Path Relinkig e apresentou um desempenho superior (em termos de qualidade de soluções) com relação à heurística ACO de Gagne et al. (2002). Neste artigo, o algoritmo GRASP com Path Relinking de Gupta e Smith (2006) é denotado por GRASP-PR. Os testes computacionais das heurísticas propostas são realizados utilizando dois conjuntos de problemas teste disponíveis na literatura: Conjunto 1: composto por 32 problemas teste gerados por Rubin e Ragatz (1995). Este conjunto de problemas é dividido em grupos de oito problemas com n = 15, 25, 35 e 45 tarefas. Conjunto 2: formado por 32 problemas gerados por Gagne et al. (2002). Este conjunto de problemas também é dividido em grupos de oito problemas com n = 55, 65, 75 e 85 tarefas. Na avaliação das heurísticas foram testados diferentes valores para os parâmetros usados. Os parâmetros que geraram os melhores resultados são os seguintes: Taxa de aleatoriedade: α = 0,6 para problemas com n = 15, 25 e 35; α = 0,4 para problemas com n = 45, 55 e 65; α = 0,2 para problemas com n = 75 e 85. Número máximo de iterações GRASP: I max = 100. Número máximo de iterações ILS : I ILS = 1000. 3.1. Comparação dos resultados obtidos Para os 32 problemas do Conjunto 1 (com número de tarefas variando entre 15 e 45), em 14 problemas, a heurística GRASP-VND foi melhor que a heurística GRASP-VNS. A heurística GRASP-VNS foi melhor que GRASP-VND em 7 problemas. Em 11 problemas as duas heurísticas encontraram o mesmo valor do atraso total. Resumindo, para o primeiro conjunto de problemas, a heurística GRASP-VND foi melhor. Para o Conjunto 2 (problemas com número de tarefas entre 55 e 85), a heurística GRASP-VNS foi melhor. Para os 32 problemas deste conjunto, o algoritmo GRASP-VND mostrou-se melhor que o GRASP-VNS em apenas 6 problemas, enquanto o GRASP-VNS foi melhor que o GRASP-VND em 17 problemas. Em 9 problemas as duas heurísticas encontraram o mesmo valor do atraso total. Comparando o valor médio do atraso total, a heurística VNS foi melhor nos dois conjuntos de problemas. Na Tabela 1, mostram-se os valores dos atrasos obtidos pelas duas heurísticas, GRASP-VNS e GRASP-VND para cada um dos problemas do Conjunto 1 e 2. 1338

Tabela 1. Valores dos atrasos obtidos pelas heurísticas para os dois conjuntos de problemas. Problema n GRASP-VNS GRASP-VND Problema n GRASP-VNS GRASP-VND p401 15 128 94 p551 55 333 335 p402 15 0 0 p552 55 0 0 p403 15 3444 3418 p553 55 41405 41487 p404 15 1122 1067 p554 55 14942 15243 p405 15 0 0 p555 55 50 38 p406 15 0 0 p556 55 0 0 p407 15 1921 1861 p557 55 36478 36382 p408 15 5703 5660 p558 55 20287 20362 p501 25 269 267 p651 65 443 424 p502 25 0 0 p652 65 0 0 p503 25 3512 3524 p653 65 58636 59049 p504 25 0 0 p654 65 34994 35648 p505 25 0 0 p655 65 103 63 p506 25 0 0 p656 65 0 0 p507 25 7317 7293 p657 65 55661 56228 p508 25 1946 1915 p658 65 27982 28307 p601 35 79 47 p751 75 391 368 p602 35 0 0 p752 75 0 0 p603 35 17842 17873 p753 75 79387 79506 p604 35 19184 19366 p754 75 36196 36601 p605 35 298 301 p755 75 0 0 p606 35 0 0 p756 75 0 0 p607 35 13211 13298 p757 75 61320 61697 p608 35 4790 4732 p758 75 38919 39691 p701 45 164 155 p851 85 626 681 p702 45 0 0 p852 85 0 0 p703 45 26841 27060 p853 85 99860 100282 p704 45 15380 15668 p854 85 81361 82581 p705 45 293 282 p855 85 530 498 p706 45 0 0 p856 85 0 0 p707 45 24120 24203 p857 85 88910 89743 p708 45 23000 23191 p858 85 75666 76791 Média 5330,1 5352,3 26702,5 26937,7 A seguir, apresentam-se os resultados obtidos pelas heurísticas GRASP-VNS e GRASP-VND quando é acrescentado o procedimento de pós-otimização baseado na heurística ILS. Estes resultados são comparados com os resultados encontrados pela heurística GRASP-PR de Gupta e Smith (2006). No trabalho de Gupta e Smith (2006) o algoritmo GRASP-PR é executado 20 vezes para resolver cada problema teste. Portanto, as heurísticas GRASP-VNS e GRASP-VND com ILS também são executadas 20 vezes para cada problema. Neste trabalho são comparadas as melhores soluções obtidas (nas 20 execuções) pelas 3 heurísticas: GRASP+VNS+ILS, GRASP+VND+ILS e GRASP-PR. Para o Conjunto 1 de problemas as melhores soluções obtidas pelas 3 heurísticas são comparadas com as soluções determinadas pelo algoritmo Branch and Bound (B&B) de Ragatz (1993). Vale lembrar que as soluções geradas pelo algoritmo B&B não necessariamente são ótimas devido à execução deste algoritmo ter sido limitada à exploração de dois milhões de nós. A eficiência de cada heurística é medida calculando o erro relativo percentual com relação ao algoritmo B&B: T TB ER% = & B 100, TB& B onde T e T B&B são os valores do atraso total obtidos por um algoritmo GRASP e pelo método B&B, respectivamente. Vale destacar que o valor de ER% é considerado zero se T B&B = 0 e T = 0. 1339

Note que, se T < T B&B, o valor de ER% será negativo. Neste caso ER expressa o percentual de melhoria de um algoritmo GRASP com relação ao B&B. Na Tabela 2 são apresentados os resultados da comparação das melhores soluções obtidas pelas 3 heurísticas (GRASP+VNS+ILS, GRASP+VND+ILS e GRASP-PR) para os 32 problemas do Conjunto 1. Pode-se observar que, dos 32 problemas, a heurística proposta GRASP+VNS+ILS mostra, em 3 problemas, melhores resultados quando comparada com as outras duas heurísticas, GRASP+VND+ILS é melhor que as outras em 1 problema, e GRASP-PR é melhor que as outras heurísticas em 2 problemas. Em 5 problemas, as heurísticas GRASP-PR e GRASP+VND+ILS encontraram as mesmas soluções e melhores que as soluções de GRASP+VNS+ILS. Em 2 problemas, GRASP-PR e GRASP+VNS+ILS obtiveram os mesmos valores do atraso total (T) e estes valores melhores que os obtidos por GRASP+VND+ILS. E em 19 problemas, as três heurísticas encontraram o mesmo valor de T. Tabela 2. Resultados para o Conjunto 1 de problemas: comparação dos valores do erro relativo com relação ao algoritmo B&B. B&B GRASP_PR GRASP+VNS+ILS GRASP+VND+ILS Problema n T B&B ER% Time* ER% Time ER% Time p401 15 90 0,0 4 4,4 0,4 0,0 0,3 p402 15 0 0,0 0 0,0 0 0,0 0 p403 15 3418 0,0 3,7 0,0 0,5 0,0 0,3 p404 15 1067 0,0 2,5 0,0 0,4 0,0 0,3 p405 15 0 0,0 0 0,0 0 0,0 0 p406 15 0 0,0 0 0,0 0 0,0 0 p407 15 1861 0,0 3,9 0,0 0,5 0,0 0,3 p408 15 5660 0,0 3,2 0,0 0,4 0,0 0,3 p501 25 264-1,1 14-0,8 3,3-1,1 1,4 p502 25 0 0 0 0 0 0 0 p503 25 3511-0,4 18,5-0,4 2-0,4 1,6 p504 25 0 0,0 0 0,0 0 0,0 0 p505 25 0 0,0 0 0,0 0 0,0 0 p506 25 0 0,0 0 0,0 0 0,0 0 p507 25 7225 0,0 24,4 0,0 3,6 0,0 1,73 p508 25 2067-7,4 23,3-7,4 2,4-7,4 1,68 p601 35 30-46,7 53,3 16,7 6-46,7 4,6 p602 35 0 0,0 0 0,0 0 0,0 0 p603 35 17774-1,1 94,4-1,1 9,1-1,0 4,9 p604 35 19277-0,9 88,8-0,9 12,4-1,0 4,7 p605 35 291-16,5 59-6,2 5,3-20,3 4,7 p606 35 0 0,0 0 0,0 0 0,0 0 p607 35 13274-2,3 88-2,2 8,3-2,2 4,8 p608 35 6704-29,4 83,5-29,4 7,5-29,4 5 p701 45 116-11,2 122,5 11,2 19-10,4 9,73 p702 45 0 0,0 0 0,0 0 0,0 0 p703 45 27097-1,8 216,4-2,1 25,1-2,0 10,8 p704 45 15941-4,6 201,3-4,6 24,7-4,6 10,5 p705 45 234-5,1 129,9 4,7 18,3-9,4 10,1 p706 45 0 0,0 0 0,0 0 0,0 0 p707 45 25070-5,0 253,3-5,0 25,9-4,8 11,1 p708 45 24123-5,5 267-5,4 15,6-5,5 10,7 Média 54,8 6,0 3,1 * Processador Pentium IV, 2.4 GHz, 1GB de RAM. 1340

Na Tabela 2 também são apresentados os tempos de CPU em segundos (Time) gastos por cada algoritmo. Mesmo que os algoritmos tenham sido executados em computadores com processadores diferentes (GRASP-PR: Pentium IV 2.4, GRASP+VND+ILS e GRASP+VNS+ILS: Pentium IV 3.0), os tempos das heurísticas propostas são bem menores em comparação aos tempos do GRASP-PR. Nos 32 problemas do Conjunto 1, as médias de tempo gasto pelos algoritmos GRASP+VND+ILS, GRASP+VNS+ILS e GRASP-PR são 3,1, 6,0 e 54,8 segundos, respectivamente. Tabela 3. Resultados para o Conjunto 2 de problemas: comparação dos melhores valores do atraso total obtidas pelas heurísticas. GRASP_PR GRASP+VNS+ILS GRASP+VND+ILS Problema n T Time* T Time T Time p551 55 242 258,2 260 25,2 209 19 p552 55 0 0 0 0 0 0 p553 55 40678 511,8 40630 46,8 40668 21,1 p554 55 14653 497,1 14653 45,4 14675 21,1 p555 55 0 219,8 15 31,6 0 11 p556 55 0 0 0 0 0 0 p557 55 35883 557 35853 49,4 35900 21,6 p558 55 19871 541,8 19890 39,7 19871 21,6 p651 65 333 460,8 322 53,6 293 33,3 p652 65 0 0 0 0 0 0 p653 65 57880 1023 57682 80,8 57890 37,5 p654 65 34410 939,7 34316 72,2 34432 36,7 p655 65 30 521,2 43 36,1 18 34,3 p656 65 0 0 0 0 0 0 p657 65 55355 1143,4 54919 82,8 55005 39,2 p658 65 27114 1029,9 27139 68,3 27201 38,9 p751 75 317 811,1 301 70,8 267 54,8 p752 75 0 0,05 0 0 0 0 p753 75 78211 1875 77740 127,2 78156 59,4 p754 75 35323 1671,1 35221 129,3 35417 57,7 p755 75 0 0 0 1 0 0,1 p756 75 0 0 0 0 0 0 p757 75 60217 1848,9 59803 125,8 60107 63,8 p758 75 38368 2000,3 38363 145 38454 59,9 p851 85 531 1355,5 502 114,7 429 86,7 p852 85 0 0 0 0 0 0 p853 85 98794 3022,4 97969 182,2 98313 94,7 p854 85 80338 2832,4 79361 210 80077 89,3 p855 85 393 1400,8 404 112 318 90,3 p856 85 0 0,05 0 0 0 0 p857 85 88089 3217 87476 171,8 87864 101,2 p858 85 75217 3714,4 74816 209,8 75116 101,39 Média 982,9 69,7 37,3 * Processador Pentium IV, 2.4 GHz, 1GB de RAM. Na Tabela 3 mostra-se os melhores valores do atraso total (T) obtidos pelas 3 heurísticas para os 32 problemas do Conjunto 2. Nota-se que a heurística GRASP+VNS+ILS obteve os menores valores de T para 14 problemas, a heurística GRASP+VND+ILS para 5 problemas e o algoritmo GRASP-PR apenas para 1 problema. Observa-se, ainda, que em 2 casos as heurísticas GRASP+VND+ILS e GRASP-PR obtiveram os mesmos resultados e que estes foram melhores dos que os obtidos pelo GRASP+VNS+ILS, em 1 caso os algoritmos GRASP- 1341

PR e GRASP+VNS+ILS chegaram ao mesmo valor do atraso total e este valor melhor do que o conseguido por GRASP+VND+ILS. Para os outros 9 problemas, as 3 heurísticas encontraram o mesmo valor do atraso total. A Tabela 3 também apresenta os tempos computacionais gastos pelos algoritmos. Notase que na maioria dos problemas, os tempos gastos pelas heurísticas propostas são bem menores que os tempos do algoritmo GRASP-PR. Para o problema p858 com 85 tarefas a heurística GRASP-PR gastou 3714,4 segundos, a heurística GRASP+VNS+ILS gastou 209,8 e a heurística GRASP+VND+ILS somente gastou 101,39 segundos. Para este problema, as heurísticas propostas obtiveram uma solução com menor atraso total se comparados com GRASP-PR. Na média, para resolver cada problema, a heurística GRASP+VNS+ILS gasta 69,7 segundos e a heurística GRASP+VND+ILS gasta 37,33 segundos, já a heurística GRASP-PR gasta 982,9 segundos (14 vezes mais demorada que o GRASP+VNS+ILS e 26 vezes mais demorada que o GRASP+VND+ILS). 4. Conclusões Neste artigo foram propostas duas heurísticas GRASP para resolver o problema de programação de tarefas em uma máquina com tempos de preparação (setup time) dependentes da seqüência. O objetivo do problema é minimizar o atraso total das tarefas com relação a suas datas de entrega. É um problema bastante importante que é encontrado em várias situações práticas no planejamento e controle da produção. As heurísticas propostas combinam dois métodos: o método greedy randomized adaptive search procedure (GRASP) e método Iterated Local Search (ILS). No método GRASP foram testadas duas buscas locais baseadas nas heurísticas VNS e VND. O objetivo do GRASP é determinar rapidamente uma solução ótima local de boa qualidade. O método ILS é utilizado como um método de pós-otimização com a tentativa de melhorar a solução obtida pelo GRASP. Estes métodos contribuíram fortemente para o bom desempenho do algoritmo proposto. É importante ressaltar que o método ILS foi fundamental para a obtenção de soluções de alta qualidade. Neste trabalho, as heurísticas GRASP com ILS são comparadas com uma heurística GRASP com path relinking (GRASP-PR) proposta por Gupta e Smith (2006). Vale lembrar que a heurística GRASP-PR anteriormente foi comparada com outras heurísticas propostas na literatura e mostrou ser superior. Dos testes computacionais realizados podemos concluir que as heurísticas propostas GRASP-ILS, em termos de qualidade de solução, são bastante eficientes quando comparadas com a heurística GRASP-PR. Do total de 64 problemas resolvidos, o GRASP+VND+ILS obteve a melhor solução em 8 problemas e o algoritmo GRASP+VNS+ILS em 15. O algoritmo GRASP- PR encontrou a melhor solução em apenas 3 problemas. O GRASP+VND+ILS encontrou a mesma solução do GRASP-PR, porém melhor que a solução de GRASP+VNS+ILS em 7 problemas e o GRASP+VNS+ILS encontrou solução igual ao GRASP-PR e melhor que a solução de GRASP+VND+ILS em 3 casos. As três heurísticas encontraram a mesma solução em 28 problemas. Outra característica importante das heurísticas propostas é a rapidez quando comparadas com o algoritmo GRASP-PR. Em média o GRASP+VNS+ILS é 14 vezes mais rápido que o GRASP-PR e o GRASP+VND+ILS é 26 vezes mais rápido que o GRASP-PR. Agradecimentos O presente trabalho foi financiado pelo Conselho Nacional de Desenvolvimento Científico e Tecnológico CNPq (processos: 504796/2007-0, 312039/2006-9) e pela Fundação de Amparo à Pesquisa do Estado de Minas Gerais FAPEMIG (processo: APQ3768-6.01/07). Referências 1342

Allahverdi, A., Gupta, J.N.D. e Aldowaisan, T. (1999), A review of scheduling research involving setup considerations, OMEGA, 27, 219-239. Allahverdi, A., Ng, C.T., Cheng, T.C.E. e Kovalyov, M.Y. (2008), A survey of scheduling problems with setup times or costs, European Journal of Operational Research, 187, 985 1032. Armentano, V.A. e Mazzini, R. (2000), A genetic algorithm for scheduling on a single machine with set-up times and due dates, Production Planning and Control, 11, 713 720. Du, J. e Leung, J.Y.T. (1990), Minimizing total tardiness on one machine is NP-hard, Mathematics of Operations Research, 15, 483-495. Feo, T. e Resende, M. (1995), Greedy Randomized Adaptive Search Procedures, Journal of Global Optimization, 2, 1 27. Festa, P. e Resende, M.M.G.C. (2004), An Annotated Bibliography of GRASP, European Journal of Operational Research, paper submitted. França, P.M., Mendes, A. e Moscato, P. (2001), A memetic algorithm for the total tardiness single machine scheduling problem, European Journal of Operational Research, 132, 224 242. Gagne, C., Price, W.L. e Gravel, M. (2002), Comparing an ACO algorithm with other heuristics for the single machine scheduling problem with sequence-dependent setup times, Journal of the Operational Research Society, 53, 895 906. Gupta, S.R. e Smith, J.S. (2006), Algorithms for single machine total tardiness scheduling with sequence dependent setups, European Journal of Operational Research, 175, 722 739. Laguna M. e Martí, R. (1999), GRASP and path relinking for 2-layer straight line crossing minimization, INFORMS Journal on Computing, 11, 44-52. Lee, Y.H., Bhaskaran, K. e Pinedo, M. (1997), A Heuristic to Minimize the Total Weighted Tardiness with Sequence-Dependent Setups, IIE Transactions, 29, 45 52. Lourenço, H. R., Martin, O. C. e Stützle, T. (2003), Iterated local search, Handbook of metaheuristics, 321 353. Mladenovic, N. e Hansen, P. (1997), Variable neighborhood Search, Computers and Operations Research, 24, 1097-1100. Ragatz G.L. (1993), A branch-and-bound method for minimum tardiness sequencing on a single processor with sequence dependent setup times, Proceedings: twenty-fourth annual meeting of the Decision Sciences Institute, 1375 1377. Rubin P.A. e Ragatz G.L. (1995), Scheduling in a sequence dependent setup environment with genetic search, Computers and Operations Research, 22(1), 85 99. Sen, T. e Gupta, S.K. (1984), A State-of-Art Survey of Static Scheduling Research Involving Due Date, OMEGA, 12, 63-76. Stützle, T. (1998), Applying iterated local search to the permutation flow shop problem, AIDA- 98-04. Tan, K.C. e Narasimhan, R. (1997), Minimizing tardiness on a single processor with sequencedependent setup times: A simulated annealing approach, OMEGA, 25, 619 634. Tan, K.C., Narasimhan, R., Rubin, P.A. e Ragatz, G.L. (2000), A comparison of four methods for minimizing total tardiness on a single processor with sequence dependent setup times, OMEGA, 28, 313 326. 1343