Generering af klippemønstre. Speciale for Per Rønne

Transkript

1 Generering af klippemønstre Speciale for Per Rønne

2

3 Per Erik Rønne Side i onsdag 15. maj 1991 INDHOLDSFORTEGNELSE 1 INTRODUKTION Pseudo-Pascal. 1 2 KLIPPE OG PAKKE PROBLEMER Rørklipning. Et 1-dimensionalt problem Container-pakning. Et 3-dimensionalt problem Pladeklipning. Et 2-dimensionalt problem Gilmore & Gomory. Tidlige beskrivelser. 7 3 GUILLOTINE-KLIPNING Forskellen mellem guillotine-klipning og generel 2-dimensional klipning Forskellige heuristikker Næste der passer, faldende højde. (NFDH) Første der passer, faldende højde. (FFDH) Sleators algoritme. (SLEA) Splitte-passe algoritmen. (SFIT) Den modificerede Sleator-algoritme. (MSLEA) Den modificerede næste der passer, faldende højde. (MFFDH) Effektivitet af heuristikkerne BENYTTEDE ALGORITMER Gilmore & Gomory Ford & Fulkerson Desler & Hakimi Christofides & Whitlock Reduktioner af søgetræ Hjælpestrukturer Klippemønsters værdi Valg af rektangel til klipning Algoritmen Forbedringer af algoritmen Albano & Orsini: En suboptimal løsning Generering af strimler Generering af subproblemer Algoritmen. 56

4 Per Erik Rønne Side ii onsdag 15. maj ØVRIGE ALGORITMER Wang: Sammenføjning af rektangler Algoritme Algoritme Tærskelværdiernes størrelse Oliveira & Ferreira: En forbedring af Wangs algoritme Oli Madsen og den rejsende sælger Beasley: En generel løsning PROJEKT Database Plader og rester Emner og sæt. Superemner Emnegrupper. Liste af superemner der skal genereres klippemønster for Emne/Plade kombinationer Pladelager / Restlager Nødvendigt spild Løbenumre Menusystem SAMMENFATNING Testresultater Sammenligning med Albano & Orsinis algoritme Fundne værdier Opnåede klippemønstre Antal normalklip På antal klip På CPU-tid Christofides & Whitlocks egne resultater Konklusion KILDETEKSTER TIL PROGRAMMER C-programmer Common.h Common.c Debug.c NormalCuts.c Gilmore.c Desler.c Christofides.c Christofides.main.c Pro*C-programmer SQL_Interface.pc Database: SQL*Plus kommandofiler Database.sql Defaults.sql Itemdef.sql Matrdef.sql 163

5 Per Erik Rønne Side iii onsdag 15. maj Matrdef.ins Nestdef.sql Setsdef.sql Stockadm.sql Remaining.sql LITTERATUR REGISTER. 185

6 Per Erik Rønne Side iv onsdag 15. maj 1991

7 Per Erik Rønne Side 1/184 onsdag 15. maj INTRODUKTION Dette er mit speciale på hovedfagsstudiet i datalogi ved Københavns Universitet. Specialet drejer sig om klippemønstergenerering, det der på engelsk hedder cutting stock. Der tages udgangspunkt i en database der er udviklet i forbindelse med et EF-støttet projekt 1. Denne database, der er skrevet i Oracle, udvides med en lageradministrationsdel for plader og rester. Brugergrænseflader hertil er udviklet i SQL*Forms. Desuden er implementeret en algoritme (i C) som finder et optimalt klippemønster, hvor der er grænser for hvor mange emner af hver emnetype (længde bredde) der må bruges, og hvor dataene der bruges af algoritmen ligger i Oracle-databasen. Derfor er der skrevet en grænseflade til databasen i Pro*C ( embedded SQL ). Den implementerede algoritme er sammenlignet med en allerede implementeret heuristik, der finder en suboptimal løsning. Der ses på, om tids- og lagerforbruget ved den suboptimale løsning er så meget lavere end ved den optimale, at det kan betale sig at have det større materialeforbrug der følger heraf. Programmellet er udviklet på en Apollo (UNIX) der er stillet til rådighed af firmaet Peter Matthiesen i Herlev. Den allerede implementerede heuristik er netop implementeret af dette firma, og bruges i praksis. Jeg skal hermed sige firmaet tak for hjælp, lån og vejledning under programudviklingen. Jeg har som specialevejleder haft professor, dr. scient. Jakob Krarup. Jeg skal ligeledes takke ham for hans hjælp og vejledning under projektet. Rapporten er skrevet på en Macintosh med brug af Microsoft Word/4, Microsoft Excel og MacDraw-II Pseudo-Pascal. De benyttede algoritmer beskrives i rapporten i en særlig pseudo-pascal kode. Denne kode er består i en udvidelse af Pascal til at acceptere mængder af en vilkårlig type, og til at gøre brug af de fra matematikken almindeligt kendte 1 Integration of CAD/CAM and Production Control for Sheet Metal Components Manufacturing, BRITE No. RI1B-0197-C (BA).

8 Per Erik Rønne Side 2/184 onsdag 15. maj 1991 mængdeoperatorer som (fællesmængde), (foreningsmængde), (delmængde), \ (mængdedifferens), (mængdemæssigt ekslusivt eller) m. v. For at kunne bearbejde de enkelte elementer i en mængde, er indført en særlig sætningstype: foreach <element> in <mængde> do <sætning>; Sætningen tager successivt hvert <element> i <mængde> ud, og udfører <sætning> på dem. Rækkefølgen af udtagningen er udefineret. Der er indført en uendelig løkke: loop <sætninger>; endloop; Talmængden er udvidet med værdien, uendelig. Per definition gælder at + a = hvor a er et vilkårligt tal -. De relationelle operatorer,, bruges i stedet for <=, >= og <>, fordi jeg kan få dem frem på den benyttede datamaskine. Hvor betydningen af variable fremgår af den almindelige beskrivelse af algoritmen, eller hvor deres type er selvindlysende, erklæres de ikke. Tabeller ( arrays ) kan være dynamiske, idet variable (og udtryk) kan indgå i erklæringen af dem, hvorved de får den størrelse variablene har på det sted tabellerne bliver erklæret. Som følge heraf indføres standardfunktionen NumOfElements som returnerer antallet af elementer i tabellen. Tilsvarende strukturer kan let genereres såvel i C som i (ikke-standard) Pascal; at inkludere en beskrivelse af hvordan lagerallokeringen finder sted er overflødig i forhold til algoritmebeskrivelsen, og i Pascal skal man blot huske at slå range-checking fra. Tabeller kan refereres med angivelse af færre dimensioner end de består af; i så fald er resultatet også en tabel. Meningen vil være tydelig hvor den forekommer. Af behagelighedsgrunde kan variabelerklæringer også finde sted som i Algol; en begin-end struktur er i sig selv en blok.

9 Per Erik Rønne Side 3/184 onsdag 15. maj 1991 Pseudo-Pascal koden kan lejlighedsvis indeholde rene kommentarer, som blot angiver hvad der skal udføres; deres betydning skulle være selvindlysende. Koden gør det ikke ud for at være et programmeringssprog, men blot for at være en menneskevenlig måde at beskrive algoritmer på. Posttyper ( records ) og tabeller ( arrays ) kan tildeles værdier på følgende måde: var student: record navn: string; alder: integer; end; liste: array [1 4] of integer; begin liste:= (1, 5, 7, 8); student:= ( Hans Jørgensen,23); end. Denne korte skrivemåde øger læsbarheden. Endelig bruges lejlighedsvis en mere Modula-agtig notation i forbindelse med if-sætninger (if endif), while-sætninger (while endwhile) etc. Brugen af Modula eller Pascal former skifter og afhænger af hvilken skrivemåde der er kortest; brugen af indrykninger gør at der ikke efterlades nogen tvivl.

10 Per Erik Rønne Side 4/184 onsdag 15. maj KLIPPE O G P A K K E P R O B L E M E R. For at se, hvad klippe- og pakkeproblemer drejer sig om, er det nødvendigt først at gennemgå tre eksempler, nemlig eksempler på henholdsvis et étdimensionalt, et tre-dimensionalt og et to-dimensionalt problem i den rækkefølge, fordi specialet drejer sig om 2-dimensional klipning Rørklipning. Et 1-dimensionalt problem. Lager af store rør (længde 98) Ordrer af små rør (længder 5 46) Mønstre til udklipning af små emner af store objekter Kombinationer af ordrelængder. residuallængder Som et eksempel på en-dimensional klipning kan tages et problem, der er beskrevet af Heicken & König

11 Per Erik Rønne Side 5/184 onsdag 15. maj 1991 En fabrik laver radiatorer. Som led i denne fabrikation skal der fremstilles nogle rør i længderne 5 til 46. Fabrikken har et lager af lange rør i øvrigt i et antal der i princippet er ubegrænset. Disse lange rør skal klippes til mindre stykker, svarende til det antal små rør der ugenligt er brug for. Opgaven går altså ud på at finde nogle én-dimensionale klippemønstre der reducerer spildet, the trim loss, mest muligt Container-pakning. Et 3-dimensionalt problem. Lager af store containere. Liste med små kasser. Kombination er af kasser i container. I dette tilfælde har vi et stort lager af containere, og en stor beholdning af kasser disse containere skal lastes med. Problemet er naturligvis her at udnytte den enkelte containers rum bedst muligt, så det uudnyttede rum minimeres under hensyn til begrænsninger i hvordan man rent faktisk kan stable kasser oven på hinanden. Man skal finde et rumligt pakkemønster. Sammenhængen til klippe-problemer ses i øvrigt tydeligt her. En alternativ måde at betragte problemstillingen på ville være at betragte

12 Per Erik Rønne Side 6/184 onsdag 15. maj 1991 containerne som store objekter der skal klippes ud i mindre tredimensionale emner. Man klipper altså her i det tomme rum. Operationsanalytisk set er der tale om samme problem Pladeklipning. Et 2-dimensionalt problem. Lager af store plader ("objekter") Liste af små emner Kombinationer af små emner og store rektangler Som et tredje eksempel på pakke- og klippeproblemer skal nævnes klipning af plader i mindre emner. En fabrik vil typisk have et lager af store plader, objekter, og en liste af små emner disse plader skal klippes ud i. Der kan være tale om forskellige materialer (stof, metal, glas), og dermed vil materialets egenskaber kunne bestemme om et emne vil kunne roteres (eksempelvis stofmønstre vil normalt stille sig hindrende hertil).

13 Per Erik Rønne Side 7/184 onsdag 15. maj Gilmore & Gomory. Tidlige beskrivelser. P. C. Gilmore og R. E. Gomory er klassikerne inden for klippemønstergenerering, cutting stock som det kaldes i den engelsk-sprogede litteratur. Allerede i starten af 60erne 1 offentliggjorde de deres første artikel, en artikel der et par år senere 2 fik sin fortsættelse. I disse artikler behandles det et-dimensionale problem som et lineært programmeringsproblem, og det vises at det overordentligt store antal søjler i formuleringen af LP-problemet kan klares ved at løse et tornysterproblem ved hvert pivot-trin. Endelig når de frem til at behandle problemer af flere dimensioner 3. De formulerer det to-dimensionale problem som et LP-problem, men skynder sig derefter at erklære, at we know of no economical method for solving this generalized knapsack-problem 4. I stedet viser de at der i praksis forekommer mange problemer der faktisk kan løses. Sluttelig når de frem til en algoritme (faktisk to, men den sidste virker ikke) der kan løser det to-dimensionale problem 5 når kun guillotine-klip er tilladt, og når der ikke er begrænsninger på, hvor mange emner med samme dimensioner der må klippes. Da denne algoritme senere bliver behandlet indgående, og i øvrigt i modificeret form er implementeret, skal den ikke yderligere behandles her. 1 P. C. Gilmore & R. E. Gomory: A Linear Programming Approach to the Cutting-Stock Problem. Operations Research 9, p P. C. Gilmore & R. E. Gomory: A Linear Programming Approach to the Cutting-Stock Problem II. Operations Research 11, p P. C. Gilmore & R. E. Gomory: Multi-Stage Cutting Stock Problems of Two and More Dimensions. Operations Research 13, p Side 100 i den pågældende artikel. 5 P. C. Gilmore og R. E. Gomory, The Theory and Computation of Knapsack Functions, Operations Research 15, (1967).

14 Per Erik Rønne Side 8/184 onsdag 15. maj G U I L L O T I N E-KLIPNING Forskellen mellem guillotine-klipning og generel 2- dimensional klipning. Ikke-goillotine klip Goillotine klip Ovenfor ses forskellen mellem to forskellige typer klip: Det generelle klip af rektangler, og guillotine-klippet. Guillotine-klippet er opkaldt efter en fransk læge fra slutningen af tallet, der i samarbejde med bl.a. kong Louis XVI udviklede et særligt klippeapparat, som samme konge mod sit livs afslutning fandt stadig større sympati for. Ved et guillotine-klip forstås et klip som klipper et rektangel over fra den ene side til den anden og parallelt med de to øvrige sider. Som det ses af ovenstående eksempler, vil anvendelsen af sådanne kunne give anledning til en suboptimal løsning i forhold til brugen af en mere fri klipning. Tidligere forholdt det sig således at man de fleste steder havde maskiner der kun kunne lave guillotine-klip. Sådan forholder det sig ikke mere. Klippemaskiner i dag vil i de fleste tilfælde kunne udstanse alle figurer; også

15 Per Erik Rønne Side 9/184 onsdag 15. maj 1991 cirkler og runde linier. Der er således normalt ikke længere nogen teknisk begrundelse for at holde sig til guillotine-klip. Et andet spørgsmål er imidlertid, om der findes effektive metoder til at generere klippemønstre uden guillotine-begrænsingen Forskellige heuristikker. Matthias Rode og Otto Rosenberg 1 har gennemgået tre heuristikker foreslået af E. G. Coffman, M. R. Garey, D. S. Johnson og R. E. Tarjan 2, og én foreslået af D. Sleator 3. På basis heraf foreslår de to forbedrede heuristikker. Gennemgangen foreår med et konkret eksempel på hvilke hvilke emner der skal klippes, og hvilken plade der skal bruges. Der er 12 emner, som angivet nedenfor: Sæt af emner der skal klippes. Emnernes mål er mere nøjagtigt angivet ved: (Id, Length, Width, NumToNest) = (( 1,20,80,1), ( 2,15,80,1), ( 3,65,25,2), ( 4,80,20,1), ( 5,50,20,1), ( 6,15,20,1), ( 7, 5,20,1), ( 8,15,15,1), ( 9,10,15,1), (10, 5,15,1), (11,50,10,1)). 1 Matthias Rode & Otto Rosenberg: An Analysis of Heuristic Trim-Loss Algorithms. Engineering Costs and Production Econimics, 12, p , E. G. Coffman, M. R. Garey, D. S. Johnson & R. E. Tarjan: Performance Bounds for Level-Oriented Two- Dimensional Packing Algorithms. SIAM, J. Comput. 9: D. Sleator: A 2.5 Times Optimal Algorithm for Packing in Two Dimensions. Info. Proc. Lett., 10:

16 Per Erik Rønne Side 10/184 onsdag 15. maj 1991 Disse emner kan ved et optimal klippemønster være på en plade med målene Ved ikke-optimale klippemønstre tænkes pladen udvidet i højden. Et optimalt klippemønster ser således ud: Plade til klipning Optimalt klippemønster Som det ses er det muligt at klippe pladen på en sådan måde, at der ikke spildes noget materiale og klippemåden er endda af guillotine-type.

17 Per Erik Rønne Side 11/184 onsdag 15. maj Næste der passer, faldende højde. (NFDH) Klippemønster Klippemønster med bredere plade Uklippede emner Den første algoritme ordner emnerne i rækkefølge efter ikke-stigende bredde (= højde). Derefter placeres de i strimler, der genereres nedefra, i den angivne rækkefølge. Er en strimmel opbrugt, fortsættes i strimlen ovenfor.

18 Per Erik Rønne Side 12/184 onsdag 15. maj Første der passer, faldende højde. (FFDH) Klippemønster Klippemønster med bredere plade Uklippede emner Denne heuristik adskiller sig kun fra den forrige ved at emnerne nu placeres i den laveste strimmel, hvor der er plads til den. Spildet er dog det samme.

19 Per Erik Rønne Side 13/184 onsdag 15. maj Sleators algoritme. (SLEA) PlateLength/2 11 PlateLength/ W W 4 Klippemønster Klippemønster med bredere plade Uklippede emner Alle emner med en bredde på mere end PlateLength/2 placeres oven på hinanden nederst på pladen. Den højde de når til kaldes W. Resten af emnerne skal placeres på højden W, følgende princippet om næste der passer, faldende højde, indtil der alle emner er placeret, eller der ikke er plads til flere. Det giver sig selv, at der vil være plads til mindst to emner. Derefter deles den resterende plade i to halvdele med længden PlateLength/2, som indikeret på tegningen. På det nederste, højre rektangel placeres de resterende emner efter princippet om næste der passer, faldende højde, idet den øverste, venstre rektangel ligger over emnerne 1 og 2.

20 Per Erik Rønne Side 14/184 onsdag 15. maj Splitte-passe algoritmen. (SFIT) 2/3 11 2/ W A W Klippemønster A Klippemønster med bredere plade Uklippede emner Denne heuristik deler emnelisten i to lister L 1 og L 2., begge ordnet efter ikke-stigende højde. L 1 indeholder alle emner med bredder større end PlateLength(m + 1); L 2 resten. Variablen m kan beregnes som floor(platelength/piecelength max )). I det angivne eksempel bliver L 1 = (5, 3, 3), hvor tallene hentyder til numrene på figurerne. Disse emner placeres efter FFDH-algoritmen. Disse emner deles derefter i to blokke, idet de emner der ligger på niveauer/strimler med en samlet længde på over PlateLength*(m + 1)/(m + 2) 65 placeres neden under de øvrige. Et rektangulært område, A dannes da over den brede blok

21 Per Erik Rønne Side 15/184 onsdag 15. maj 1991 og til venstre for den lille blok. Dette udfyldes da ved hjælp af FFDH-algoritmen op til den øverste bloks øverste kant. Derefter udfyldes resten ved hjælp af FFDH-algoritmen oven over den øverste blok Den modificerede Sleator-algoritme. (MSLEA) 2/3 PlateLength/2 2/ W A W 5 Klippemønster A Klippemønster med bredere plade Uklippede emner Denne heuristik gør brug af visse idéer fra SFIT, idet emner med en bredde på mere end PlateLength/2 placeres på samme måde som i splitte-passe heuristikken med m sat til 1. Nu kan man skabe en rektangel A til brug for emner med længder på PlateLength/3 eller mindre, og med brug af FFDH. Derefter placeres de resterende emner på samme måde som ved Sleator-algoritmen, idet der dog bruges

22 Per Erik Rønne Side 16/184 onsdag 15. maj 1991 FFDH i stedet for NFDH for at placere emner på det laveste mulige niveau over den nederste blok Den modificerede næste der passer, faldende højde. (MFFDH) PlateLength/2 PlateLength/ A A 3 5 Klippemønster 3 3 Uklippede emner Klippemønster med bredere plade Denne heuristik virker i begyndelsen som FFDH. Så snart et emne overskrider grænsen PlateLength/2 kan der imidlertid dannes et areal A med længden PlateLength/2 og højden op til det første (og dermed højeste) af de allokerede emner. Nu kan dette areal allokeres under brug af FFDH. Ved højden på det hidtil højeste emne fortsættes med samme metode.

23 Per Erik Rønne Side 17/184 onsdag 15. maj Effektivitet af heuristikkerne. Rode & Rosenberg har analyseret de seks heuristikker og har fundet ud af at følgende sammenhæng mellem antallet af emner og den tid det tager at løse problemet: NFDH O(N log N) FFDH O(N 2 ) SLEA O(N log N) SFIT O(N 2 ) MSLEA O(N 3) MFFDH O(N 3 ) Ved at implementere algoritmerne får de følgende rangordning af algoritmernes effektivitet: MFFDH > FFDH > MSLEA > SFIT > SLEA > NFDH. Det er dog den generelle opfattelse at ingen af disse heuristikker udnytter pladsen godt nok.

24 Per Erik Rønne Side 18/184 onsdag 15. maj B E N Y T T E D E A L G O R I T M E R Gilmore & Gomory. P. C. Gilmore og R. E. Gomory 1 har udviklet to algoritmer til at beregne 2- dimensionale tornysterproblemer. Disse algoritmer løser også det 2-dimensionale cutting-stock problem 2, når der ikke er begrænsninger for antallet af emner (fordelt på emnetyper), der må klippes 3. Forfatterne angiver selv den anden algoritme (benævnt 2B) som den mest effektive af de to. Uheldigvis er der dog fejl i denne algoritme, som der da også er gjort opmærksom på af S. Hahn 4. Derfor skal den første algoritme (benævnt 2A) benyttes her. Algoritmen diskretiserer cutting-stock problemet, således at en plade kun kan klippes med en nøjagtighed af eksempelvis 1 mm hvilket i øvrigt i praksis virker meget rimeligt. Derefter gøres der brug af en 2-dimensional tabel med 3 attributter. Tabellens størrelse er bestemt af pladens størrelse, idet den vil have (pladelængde pladebredde) indgange. Er de tre attributter af typen long i C (hvilket er det mest effektive og dermed hyppigst brugte type for heltal), og betragter vi en plade på 2 2 meter, vil tabellen altså komme op på = 4 M indgange og = 48 M bytes. Algoritmen initialiserer først F[x,y] til (pladelængde, pladebredde, F0(x,y)), hvor F0(x,y) er en hjælpefunktion der finder værdien af den mest værdifulde emnetype der kan ligge en rektangel med længden x og bredden y. Derefter går den ind i en proces, hvor den opdaterer attributterne i F[x,y], hvis det er muligt at foretage et guillotine-klip på rektanglet (x,y), og hvis enten 1 P. C. Gilmore og R. E. Gomory, The Theory and Computation of Knapsack Functions, Operations Research 15, (1967). 2 Faktisk giver algoritmen algoritmen kun værdien af et optimalt klippemønster; den kan dog relativt let også udvides til at give antallet af emner der bliver klippet fordelt på emnetyper, samt det rent faktisk fundne klippemønster; dette er da også hvad jeg har gjort. 3 Denne problemtype kaldes fremover det ubegrænsede (engelsk: unconstrained) problem, mens den problemtype hvor der er grænser på antallet af emner der må/skal klippes kaldes det begrænsede (engelsk: constrained) problem. 4 S. Hahn, On the Optimal Cutting of Defective Glass Sheets, I.B.M. New York Scientific Center Report No , (1967).

25 Per Erik Rønne Side 19/184 onsdag 15. maj 1991 værdien af de to delrektangler er større end eller lig med værdien af det oprindelige rektangler. Den nøjagtige algoritme ser således ud: type TType = record length, width, value: integer; end; var T: array [1 PlateLength, 1 PlateWidth] of TType; funtionf F0 (x, y: integer): integer; begin F0:= 0; for i:= 1 to NoOfPieces do if Pieces[i].length x Pieces[i].width y then 1 F0:= max (F0, Pieces[i].value); 2 endif; endfor; end; begin Initialization of table for RectLength:= 1 to PlateLength do for RectWidth:= 1 to PlateWidth do F[RectLength,RectWidth]:= (PlateLength, PlateWidth, F0(RectLength,RectWidth)); endfor; endfor; 1 Ønskes mulighed for at emnerne kan rotere, udvides betingelsen med et Pieces[i].length y Pieces[i].width x. 2 Ønskes oplysninger om benyttet emne (og klippemønster) genereret, indsættes oplysninger om det her. Ved klippemønster skal der naturligvis være forberedt for at der kan være tale om en liste af emner placeret et bestemt sted på rektangelet.

26 Per Erik Rønne Side 20/184 onsdag 15. maj 1991 Final calculation of table for RectWidth:= 1 to PlateWidth do for RectLength:= 1 to PlateLength do for NextXCut:= 1 to RectLength - 1 do V:= F[NextXCut, RectWidth].value + F[RectLength - NextXCut, RectWidth].value; if V > F[RectLength, RectWidth].value then F[RectLength, RectWidth]:= (NextXCut, RectWidth, V) 1 else if V = F[RectLength, RectWidth].value then F[RectLength, RectWidth].length:= NextXCut; endif; endfor; for NextYCut:= 1 to RectWidth - 1 do V:= F[RectLength, NextYCut].value + F[RectLength, RectWidth - NextYCut].value; if V > F[RectLength, RectWidth].value then F[RectLength, RectWidth]:= (RectLength, NextYCut,V) 2 else if V = F[RectLength, RectWidth].value then F[RectLength, RectWidth].length:= NextYCut; endif; endfor; endfor; endfor; end. Efter udførelsen af algoritmen, kan F bruges på følgende måde: F[x,y].value angiver værdien af rektangel med målene (x,y). Hvis F[x,y].length = x F[x,y].width = y er rektanglet (x,y) et færdigklippet rektangel. Hvid F[x,y].length < x bliver (x,y) klippet til de to rektangler angivet ved (F[x,y].length, y) og (x - F[x,y], y). Skulle ingen af de to ovennævnte muligheder være tilfældet, bliver (x,y) klippet til (x, F[x,y].length) og (x, y - F[x,y].length). Lagerforbruget (48 M for en 4 m 2 stor plade) virker naturligvis helt vanvittigt. Bruger man imidlertid ikke datastrukturen array til den store tabel, men derimod en passende hægtet struktur, nedsættes dette forbrug dog til en mere realistisk størrelse. Dette er da også hvad jeg har gjort Ford & Fulkerson. L. R. Ford og D. R. Fulkerson 3 foreslår følgende løsning på problemet om den korteste vej i en graf: 1 Ved klippemønstergenerering bør også oplysninger om nyt klippemønster lagres her. 2 Ved klippemønstergenerering bør også oplysninger om nyt klippemønster lagres her. 3 L. R. Ford, jr, og D. R. Fulkerson, Flows in Networks, Princeton University Press, Princeton, N.J

27 Per Erik Rønne Side 21/184 onsdag 15. maj 1991 Idet den knude, hvorfra vejen skal udgå fra kaldes s, forsynes alle knuder x i grafen med etiketter af typen [-, π(x)], hvor π(s) = 0 og hvor π(x) = for x s. Derefter søges kanter [x,y] hver med længden a(x,y). Så længe man finder kanter [x,y] hvor π(x) + a(x,y) < π(y), ændres knude y s etikette til (x, π(x) + a(x,y)). Efter afslutning af algoritmen vil etiketten til en vilkårlig knude indeholde dels den korteste længde til s, dels en angivelse af hvilken af knudens kanter der er en del af den korteste sti til s. type VertexPointer = ^VertexKind; VertexKind = record back: VertexPointer; weight: integer; end; BranchKind = record from, till: VertexPointer; weight: integer; end; begin foreach v in vertex in graph v:= (nil, ); source:= (nil, 0); source is vertex in graph continue:= true; while continue begin continue:= false; foreach b in branches in graph if b.from->weight < if b.from->weight + b.weight < b.till->weight begin continue:= true; b.till:= (b.from, b.from->weight + b.weight); end; end; end. Som algoritmen er udformet af Ford & Fulkerson, kan den ikke umiddelbart bruges til det formål den skal bruges til her, nemlig at finde den korteste sti fra en vilkårlig knude i grafen til den nærmeste knude i grafen G, der tilhører en given delmængde X af grafens knuder. Tilføjes imidlertid en ekstra knude s til G med kanter til alle knuder i X med længden 0, viser det sig imidlertid at den udmærket kan bruges.

28 Per Erik Rønne Side 22/184 onsdag 15. maj 1991 Mere specifikt vil algoritmen her være udformet på en sådan måde, at der stærkt skelnes mellem to faser. I fase 1 initialiseres grafen således at alle knuder i X tildeles etiketten (nil,0), mens alle øvrige tildeles etiketten (nil, ). I fase 2, i den i ovenstående pseudo-pascal program angivne while-løkke, beregnes afstanden fra en vilkårlig knude til den nærmeste knude i X. Et særligt problem opstår ved at algoritmen kun virker, hvis alle kanter har en ikke-negativ vægt. Dette klares imidlertid ved fra alle kantvægte at subtrahere vægten af den mindste kant Desler & Hakimi. J. F. Desler og S. L. Hakimi 1 har udviklet en algoritme, der finder en generaliseret minimums-vægt kopling i en vægtet, delt graf. Først betragtes grafen G = [V, B] med knuderne V og kanterne B. En subgraf g til G defineres som havende knuderne V og en delmængde af B som kanter. Da defineres den binære operator som: g 1 g 2 = g 1 g 2 \ g 1 g 2. hvor g 1 og g 2 er subgrafer af G. Endvidere defineres graden d(v i, g) af en knude v i og en subgraf g af G som værende det antal kanter der er incidente med v i i g. Grafen G er en delt graf [(X,Y), B], hvor X Y = X Y = V. Til hver knude i V knytter vi den ikke-negative heltalsattribut constraint 2, og til hver kant i B tilknyttes realtalsattributten weight. De angivne knude-attributter siges at være mulige, hvis der eksisterer en subgraf g til G således at d( v i g) = v i.constraint for alle v i i V! 1 J. F. Desler og S. L. Hakimi, A Graph-Theoretic Approach to a Class of Integer-Programming Problems, Operations Research 17, (1969). 2! I Desler & Hakimis oprindelige artikel! har X = x, x,, x begrænsningerne α, α,, α og Y = 1 2 i 1 2 i y 1, y 2,, y j begrænsningerne β 1, β 2,, β j. I den senere transformation gøres der brug af disse L. R. Ford og D. R. Fulkerson, Flows in Networks, Princeton University Press, Princeton, N.J., 1962

29 Per Erik Rønne Side 23/184 onsdag 15. maj 1991 Vi definerer nu en vægtet graf G g. Bortset fra kantvægtene er G g = G, og kantvægtene i G og G g er de samme hvis kanterne ikke er i g; ellers negeres de. Endvidere defineres G g som en vægtet digraf (eller et netværk) ved at sætte orienteringer på G g på følgende måde: hvis b k er en kant i g går b k fra X til Y; ellers går den fra Y til X. Afslutningsvis defineres mængderne Under(g) og Over(g) som: Under(g) = v i in V d( v i,g) < v i.constraint Over (g) = v i in V d( v i,g) > v i.constraint!!! Det ses umiddelbart, at g er en mulig subgraf hvis og kun hvis Under(g) = Over(g)! =. Det! vi ønsker! er at finde er en minimums-vægtet mulig subgraf g* til G eller at finde at betingelserne er uopfyldelige. Det opfyldes i følgende algoritme, som gør brug af Ford & Fulkersons algoritme til at finde den korteste vej mellem to knuder. betegnelser.

30 Per Erik Rønne Side 24/184 onsdag 15. maj 1991 g := ; foreach v in Y g:= g the v.constraint smallest arcs incident with v; if Over(g) = return g; foreach v in X if v in Over(g) begin v.weight:= 0; v.former:= nil; end else if v in X then v.weight:= ; v.former:= nil; end; loop foreach v in Y v.weight:= ; label(g g); gold:= g; History:= ; foreach v in X Under(g) begin p:= path(v, Over(g)); if p History = and source(p) in Over(g) g:= g p; History:= History p; end; if Over(g) = return g; foreach v in X \ Over(g) if path(v, Over(g)) History v.weight:= ; foreach v in Over(gOld) \ Over(g) v.weight:= ; endloop; 4.4. Christofides & Whitlock. Nicos Christofides og Charles Whitlock 1 har udviklet en algoritme, der finder et optimalt klippemønster, hvor der er en øvre grænse for hvor mange emner af en bestemt størrelse, der skal klippes 2. Algoritmen arbejder som øvrige algoritmer under den forudsætning, at de emner der skal klippes er rektangulære, og at kun guillotine-klip er tilladte. 1 Nicos Christofides og Charles Whitlock, An Algorithm for Two-Dimensional Cutting Problems, Operations Research Vol. 25, No. 1, January-February Der er altså jvf. den tidligere definition tale om et begrænset (engelsk: constrained) problem.

31 Per Erik Rønne Side 25/184 onsdag 15. maj 1991 Der gås ud fra, at der eksisterer et endeligt antal klip på en plade; problemet diskrediteres altså ved at klips position kun kan angives med eksempelvis en millimeters præcision. Alle mulige klippemønstre af en rektangulær plade kan da genereres gennem et træ, hvis grene repræsenterer alle mulige klip på en rektangel. Givet en rektangel med længden p og bredden q vil der da i alt kunne foretages (p - 1) (q - 1) mulige klip på den. Lægges hertil det såkaldte nul-klip, som er det klip hvor der ikke foretages noget fysisk klip, fås i alt p q - 1 mulige klip på et givet rektangel (ved en bestemt knude på træet). Det er givet, at en vigtig del af en træsøgningsalgoritme må gå ud på at mindske størrelsen af dette søgningstræ Reduktioner af søgetræ. Først defineres et x-klip til at være et klip som går mellem de to længdesider i rektangelet, og et y-klip som et klip der går mellem de to breddesider i rektanglet. Da vil man kunne reducere træet på følgende måde: Symmetri. A B B A Klippemønster 1 Klippemønster 2 Betragtes nu et rektangel med længden p der x-klippes ved a, så vil det producere to rektangler A = (a, q) og B = (p - a,q), som angivet i klippemønster 1. Havde man i stedet foretaget x-klippet ved p - a havde man, som angivet i klippemønster 2, fået nøjagtigt de samme to rektangler, i den modsatte ende af det oprindelige rektangel. Reduceres de mulige x-klip fra at ligge i intervallet [1, 2,,p -1] til at ligge i intervallet [1, 2,, p div 2] (og foretages det tilsvarende for y-klip) reduceres søgetræet pludselig til en fjerdedel af dets oprindelige omfang.

32 Per Erik Rønne Side 26/184 onsdag 15. maj Klippeorden. A B C A B C Klippemønster 1 Klippemønster 2 Først betragtes rektanglet i figuren ovenfor benævnt klippemønster 1. Det klippes ved den lange brede linie i de to rektangler A::B og C. På et senere tidspunkt klippes A::B i rektanglerne A og B. Havde man i stedet (klippemønster 2) klippet i modsat rækkefølge, ville man have fået nøjagtig de samme tre rektangler frem. Indfører man derfor en regel der siger, at et x-klip ved α medfører, at alle fremtidige x-klip på dele af det pågældende rektangel skal være større end eller lig med α, så vil man reducere søgetræet yderligere uden at reducere antallet af egentligt unikke mønstre. Kombineres dette krav med det symmetrikravet, fås at for det største af de to rektangler (p - α, q) vil området af lovlige x-klip nu være begrænset til α x (p - α) div 2, og at der for det mindste rektangels vedkommende ikke vil kunne foretages flere x-klip på det.

33 Per Erik Rønne Side 27/184 onsdag 15. maj Normalklip. Fig. A. Ikke-normaliseret klippemønster Fig. B. Normaliseret klippemønster Betragtes de to klippemønstre ovenfor ses, at resultatet egentligt er ens; det i fig. B er blot presset sammen mod det venstre hjørne. Klippemønstret siges at være normaliseret. Det siger sig selv, at betragtes kun klippemønstre der er normaliserede, vil søgetræet yderligere mindskes. Samtidig er spildet koncentreret på højre side (og i toppen), hvilket vil kunne have betydning hvis vi ønsker at gøre brug af resterne. Det burde være selvindlysende, at brug af normal-klip ikke leder til en løsning der er mindre optimal end ellers. Vi kan derfor roligt lægge den begrænsning ind, at kun normalklip vil blive betragtet. Har vi et rektangel (p, q) og en liste af m emner der skal klippes, hver med målene (l i,w i ), ordnet i en ikke-faldende rækkeføge på w i og med begrænsingerne på hvor mange der må klippes b i, vil der eksistere et mængde af normale x-klip normalxcut). Der defineres en funktion f(r,x) på følgende måde: Hvis der eksisterer en eller flere heltalsvektorer v der tilfredsstiller at: x = r # v i "l i ; 0 i=1 v i b i!!!

34 Per Erik Rønne Side 28/184 onsdag 15. maj 1991 så sættes f(r,x) = w i *, hvor i * = min v (max( i v i 0)). Findes ingen vektor der tilfredsstiller ovenstående, sættes f(r, x) =. Det følger fra ovenstående definition, at hvis f(m,x) q, så er x summen af længderne l i af en kombination af emner, som overholder begrænsningerne b i, og hvor alle bredder er mindre end q. Derfor må x være et element i S q. kan genereres ved simpel rekursion: Tabellen F[r,x] for 1 r m og 0 x L 0 F[i,x] = min(f[i "1, x], max(w i, min k, (F[i "1, x " k # l i ]))) for l k min(b i, x div l i ), k heltallig, x l i ;! F[i,x] = F[i - 1, x] for x < l i F[0,x] = for alle x. En mere effektiv måde vil imidlertid være ikke at benytte rekursion. Jeg har derfor omformet algoritmen til følgende iterative procedure, som også er kraftigt pladsbesparende idet den udnytter det faktum, at kun den foregående (ikke større) emnetype er interessant:

35 Per Erik Rønne Side 29/184 onsdag 15. maj 1991 var xcuts: set of integer; procedure generatexcuts (Pieces: PieceType; Plate: PlateType); var Cuts: array [boolean, NumOfElements(Pieces)] of integer; Item, Place: integer; begin for Place:= 1 to Plate.Width do Cuts[false, Plate]:= ; for Item:= 1 to NumOfElements(Pieces) do for Place:= 1 to Plate.Length do if Place < Pieces[Item].Length then Cuts[odd(Item), Place]:= Cuts[even(Item), Place] else begin var MaxK, k, t: integer; MaxK:= min(pieces[item].numbertonest, Place/(Pieces[Item].Length); t:= ; for k:= 1 to MaxK do t:= min(t, Cuts[even(Item), Place - k*pieces[item].length]); Cuts[odd(Item), Place]:= min (Cuts[even(Item), Place], max (Pieces[Item].Width, t)); end NormalXCut:= Place N Place Plate.Width 0 end; Cuts(odd(Item)) Plate.Width Står vi da med et rektangel med bredden PlateWidth og overvejer vi at klippede den med et x-klip ved NextXCut, vil der være tale om et normalklip hvis xcuts[nextxcut] PlateWidth. På tilsvarende måde genereres den tilsvarende mængde normalycut for y- klip Hjælpestrukturer. I træet er det nødvendigt at holde regnskab med hvor vi befinder os ved hjælp af en liste L og en stak Q Liste af klippede rektangler. L er en liste over allerede genererede rektangler. Den indeholder tupler med indholdet (p, q, x, y), hvor p og q som sædvanlig betegner henholdsvis længde og bredde, mens x og y har noget at gøre med, hvor næste klipning skal finde sted. Ligger x i intervallet [1 p div 2] vil det næste klip der skal tages i betragtning være et x-klip på position x. Hvis x = p div og hvis y ligger i intervallet [1 q div 2], vil det næste klip der skal tages i betragtning være et y- klip på position y. Hvis endelig x = p div og y = q div 2 + 1, så er alle

36 Per Erik Rønne Side 30/184 onsdag 15. maj 1991 mulige x- og y-klip på rektanglet (p,q) foretaget, og det næste klip der skal foretages er et nul-klip. Listen, der initialiseres til at indeholde det rektangel der fylder hele den oprindelige plade, opdateres naturligvis løbende efterhånden som vi bevæger os rundt i træet Statusstak. Indledningsvis skal bemærkes, at algoritmen kun foretager et klip for hver knude i søgetræet. Ligeledes skal det bemærkes at ved et x-klip på et rektangel (p,q) ved α vil fremtidige x-klip på rektangler klippet herfra skulle finde sted ved værdier af x α, idet tilsvarende naturligvis gælder for y-klip 1, hvor y β. For hver knude i træet stakkes en tupel på Q med indholdet (p,q,x,y,α,β), svarende til hvad der gjaldt for L Klippemønsters værdi. Indtil nu er det ikke taget i betragtning, at de forskellige emner er tildelt en værdi. Det gøres der nu. Der gås ud fra, at det er muligt at beregne en øvre værdigrænse Z for et ufuldstændigt klippemønster 2. Endvidere må det være muligt at lagre en værdi z for den hidtil bedste fundne løsning. Det må da ved hver knude gælde at hvis Z > z og hvis antallet af brugte emner (fordelt på de forskellige emnetyper) gør klippemønstret muligt, da har vi fundet en bedre løsning 3. Vi kan sætte z:= Z og backtracke. Skulle det i stedet være tilfældet at Z z, da er vi på vej ned i et klippemønster der giver en løsning der er dårligere end hvad vi hidtil har opnået, og backtracking kan ligeledes finde sted. 1 Se ovenfor under klippeorden. 2 For de nul-klippede rektanglers vedkommende ved vi, at de ikke mere kan klippes. Derfor bruges Desler & Hakimis algoritme til at kople emner og nulklippede rektangler. For de øvriges vedkommende bruges Gilmore & Gomorys algoritme til at beregne værdien af rektanglerne, antallet af klippede emner af de forskellige typer og det brugte klippemønster. Der er tale om en øvre værdigrænse for klippemønstret fordi Gilmore & Gomorys algoritme ikke tager hensyn til at der, for hver emnetype, er begrænsinger i antallet af emner der skal klippes. 3 Skal der genereres et optimalt klippemønster må man naturligvis her smide det gamle optimale mønster ud, og i stedet gemme det nye.

37 Per Erik Rønne Side 31/184 onsdag 15. maj 1991 Skulle ingen af disse muligheder være tilfældet kan vi fortsætte med at gå ned i træet Beregning af øvre værdigrænse ved knude. Ved beregning af øvre værdigrænse for et klippemønster, opdeles sættet af klippede rektangler i to sæt, nemlig det sæt der består af nul-klippede rektangler og resten. Betragtes først de nul-klippede rektangler, kan man få en øvre grænse for deres værdi ved at tildele hver af disse et emne på en optimal måde. Dette kan gøres på følgende måde: Der oprettes en matrix a ik med m rækker svarende til de emner der skal laves, og u søjler svarende til de u nulklippede rektangler. Matrixen initialiseres på følgende måde: for i:= 1 to m do for k:= 1 to u do if Piece[i].length H [k].length 0 and Piece[i].width H 0 [k].width then 1 a ik := Piece[i].value else a ik := - ; Da er den bedst mulige allokering af emner til rektangler givet ved en løsning af følgende transportproblem: max z =!! u m "" k=1 i=1 m x ik i=1 u x k=1 ik a ik x ik " #1; k = 1 u " # b i ; i = 1 m x ik " 0; k = 1 u, i = 1 m!! 1 Hvis der skal være mulighed for at emnerne kan rotere, tilføjes: or Piece[i].rotatable and Piece[i].width H 0 [k].length and Piece[i].length H 0 [k].width

38 Per Erik Rønne Side 32/184 onsdag 15. maj 1991 hvor b i betegner begrænsningerne på hvor mange emner af hver type der må produceres. Til løsning af dette transportproblem bruges Deslers & Hakimis algoritme til at finde en minimum-vægt generaliseret matching i en delt graf, som gennemgået nedenfor. For de rektanglers vedkommende der stadig skal klippes, bruges en algoritme udarbejdet af Gilmore & Gomory til løsning af det ubegrænsede 2- dimensionale cutting stock-problem, som gennemgået ovenfor. Den ved transportproblemet fundne værdi adderes til summen af værdierne fundet for de ikkefærdigklippede rektangler, hvorved den øvre værdigrænse ved den nuværende knude er fundet Transformationer til Desler & Hakimis algoritme. 1 Ved at omformulere det ovenfor angivne transportproblem fra Christofides & Whitlocks algoritme (idet objektfunktionen samtidig negeres), fås følgende transportproblem: min z =!! u m ## "a ik x ik k=1 i=1 u " x ik # b i ; i = 1..m k=1 m " x ik #1; k = 1 u i=1 x 0; k = 1 u, i = 1 m ik! 1 Kan overspringes ved en indledende gennemlæsning.

39 Per Erik Rønne Side 33/184 onsdag 15. maj 1991 Desler & Hakimi angiver transportproblemet på to måder, nemlig den generelle T1:!! minh(t) =! n m "" k=1 i=1 h ij t ij n 0 " a i " # t j=1 ij " b i ; j = 1..n m 0 " c j " # x ik "1 ; j = 1..m i=1 0 l ij t ij k ij ; i = 1 n, j = 1 m! og specialtilfældet T2: minh(t) =! n m "" k=1 i=1 h ij t ij n 0 " a i " # t j=1 ij " b i ; i = 1 n m 0 " c j " # x ik "1 ; j = 1 m i=1 0 l ij t ij k ij ; i = 1 n, j = 1 m!

40 Per Erik Rønne Side 34/184 onsdag 15. maj 1991 Sammenholdes det redefinerede transportproblem fra Christofides & Whitlock med Desler & Hakimis første transportproblem, fås følgende transformationer: Desler & Hakimi 1: t ij h ij (t ij ) Christofides & Whitlock: x ik -a ik x ik a i 0 b i b i c j 0 d j 1 l ij 0 k ij n m m u

41 Per Erik Rønne Side 35/184 onsdag 15. maj 1991 Sammenholdes derefter Desler & Hakimis to forskellige transportproblemer, kan følgende transformationer angives: Desler & Hakimi 2 Desler & Hakimi 1 Kommentar p n + 1 q m + 1 α i b i " 1 i n m l j=1 ij γ iq b i - a i do.! f iq () 0 do. β j m d j "# l ij 1 j m j=1 γ pj d j - c j do.! f pj () 0 do. γ ij k ij - l ij 1 i n 1 j m f ij (s ij ) h ij (s ij + l ij ) + h ij (l ij ) do. α p # m j=1 (d j " c j ) β q! λ pq! f pq () 0! m " #" c j # n b i=1 i m j=1 j=1 (d j " c j )

42 Per Erik Rønne Side 36/184 onsdag 15. maj 1991 Sammenlignes de to ovenstående transformationer med hinanden, fås følgende transformation mellem Christofides & Whitlock og Desler & Hakimis andet transportproblem: Desler & Hakimi 2 Christofides & Whitlock. Kommentar p m + 1 q u + 1 α i b i 1 i m λ iq b i do. f iq () 0 do. β j 1 1 j u λ pj 1 do. f pj () 0 do. λ ij 1 i m, 1 j u f ij (s ij ) -a ik x ik do. α p β q u " m b i=1 i λ pq u f pq ()! 0

43 Per Erik Rønne Side 37/184 onsdag 15. maj 1991 Der ses nu på den vægtede, delte graf G = [(X,Y),B], hvor X = x 1, x 2,, x p og Y = y 1, y 2,, y q. Matricen k ij defineres således:! k ij = min(α i,β j,λ ij ) = & min(b i,1,") = min(b i,1) hvis i # m $ j # u m m ( min(u, % b i=1 i,u) = min(u, % b i=1 i hvis i = p$ j = q ' ( min(u,1,1) = min(u,1) hvis i = p$ j # u m ( ) min(b i,% b i,b i ) b i hvis i # m $ j = q i=1 I G er der da mellem x i og y j k ij kanter hver med vægten f ij (m) - f ij (m - 1) for 1 m k ij, svarende til -a ik m + a ik (m - 1) = -a ik hos Christofides & Whitlock. Begrænsningerne i antal kanter, hver knude kan have, bliver endelig: α = α 1,α 2,,α p = b 1,b 2,, b m,u på X β = β 1,β 2,,β p = 1, 1,, 1, " på Y m b i=1 i Sammenlignes nu med det oprindelige problem, vil der for hver emnetype være en knude i X og for hvert! nulklippet rektangel være en knude i Y. Hver knude i X vil have en begrænsning svarende til begrænsningen på antallet af emner af den pågældende emnetype der skal klippes. Hver knude i Y vil have begrænsningen 1. Hver knude i X med en begrænsning på mindst 1 vil være forbundet med hver knude i Y med én kant. Denne kant vil have samme vægt som emnetypen (negeret) hvis emnetypen kan ligge på det pågældende rektangel; ellers vil den have som som vægt. Til såvel X som Y lægges nu en knude (x p og y q ). Knuden y p vil være forbundet med hver knude i X\x p med én kant, hvis den pågældende har en begrænsning på mindst én. Knuden x p vil være forbundet med hver knude i Y\y q med én kant medmindre antallet af nulklippede rektangler er mindre end én (men så ville der jo heller ikke være noget problem at løse!). Kanterne x p og y q vil være forbundet med hinanden i et antal kanter der svarer til minimum af antallet af nulklippede rektangler og summen af de enkelte

44 Per Erik Rønne Side 38/184 onsdag 15. maj 1991 begrænsninger på emnetyper. Værdien af disse kanter vil være 0. Dermed er transformationen gennemført Valg af rektangel til klipning. I Christofides & Whitlocks egen beskrivelse af algoritmen er spørgsmålet om hvilket (ikke-nulklippede) rektangel der på et givet tidspunkt skal vælges ud til klipning, ikke angivet. I stedet angives tre mulige heuristikker. Den simpleste metode er at vælge det mindste rektangel, d. v. s. det rektangel der har den mindste længde og, hvis der findes flere sådanne, da det der har den mindste bredde. En anden metode er at vælge det rektangel for hvilket det tilsvarende ubegrænsede problem giver den højeste værdi. Da man i forbindelse med beregningen af den øvre værdigrænse bl. a. kumulerer disse værdier, og da disse værdier i forvejen ligger i en (Gilmore & Gomory) tabel, vil dette være en billig heuristik. Endelig kan man forsøge med en heuristik der forsøger at reducere søgetræet mest muligt. På et givet sted i søgetræet vil der af hvert emnetype være allokeret 1 et antal emner r i. For mindst en emnetype må det gælde at begrænsningen på hvor mange emner der må klippes, b i, er større end r i ; ellers ville en mulig løsning være fundet, og algoritmen ville have backtrack et. Da vælges det rektangel til klipning som bruger det største antal af den emnetype, som der er flest af i overskud. Christofides & Whitlock angiver at de i deres test af algoritmen bruger den sidste heuristik; det gør jeg også. 1 Ved hjælp af såvel Desler & Hakimis som Gilmore & Gomorys algoritmer.

45 Per Erik Rønne Side 39/184 onsdag 15. maj Algoritmen. I min beskrivelse af algoritmen bruges følgende datastrukturer: type PlateType = record Length, Width: integer; end; PieceType = record Length, Width, Value, NumberToNest: integer; end; RectType = record Length, Width, NextXCut, NextYCut: integer; end; StackType = record Length, Width, NextXCut, NextYCut, OldXCut, OldYCut: integer; end; var Plate: PlateType; Pieces: dynamic array of PieceType; L: set of RectType; Q: stack of StackType; NumUsed: array[1..numofelements(pieces)] of integer; ValueBound, BestSolutionSoFar: integer; Denne datastruktur er ikke forberedt på, at der skal returneres et klippemønster; er dette tilfældet skal såvel RectType som StackType udvides med felter der angiver et rektangels placering på den oprindelige plade, altså en x_location og en y_location.

46 Per Erik Rønne Side 40/184 onsdag 15. maj 1991 Denne datastruktur giver anledning til følgende algoritme, som kan modificeres som angivet i fodnoterne, hvis også klippemønsteret skal genereres. procedure christofides; begin L:= (Plate.Length, Plate.Width, 1, 1); Q:= nil; BestSolutionSoFar:= 0; loop calculate ValueBound, NumUsed for present L. 1 if ValueBound BestSolutionSoFar then backtrack if Q = nil then break else begin var feasible:= false: boolean; for i:= 1 to NumOfElements(Pieces) do feasible:= feasible and Pieces[i].NumberUsed NoUsed[i]; if feasible then begin BestSolutionFound:= ValueBound; 2 backtrack; if Q = nil then break; end else begin var R: RectType; if ( cuttable rectangle exists in L, move it to R ) then begin push (Q, (R.Length, R.Width, R.NextXCut, R.NextYCut, R.NextXCut, R.NextYCut)); 3 x_cut; end else begin backtrack; if Q = nil then break; end; end; end; endloop; end. Der forekommer her implicit kald af underprogrammer til beregning af øvre værdigrænse m. v. samt til udtagning af klipbart rektangel fra listen L. Disse rutiner er tidligere omtalt, og skal ikke yderligere omtales her. Desuden forekommer der kald af underprogrammerne backtrack og x_cut. Den sidste af disse rutiner ser således ud: 1 Ved klippemønstergenerering skal også klippemønster genereres her. 2 Ved klippemønstergenerering skal også det nye klippemønster erstatte det gamle. 3 Ved klippemønstergenerering indeholder R og Q også felterne x_location og y_location.

47 Per Erik Rønne Side 41/184 onsdag 15. maj 1991 procedure x_cut; begin loop if Q.NextXCut > Q.Length div 2 then begin y_cut; return; end; if NextXCut normalxcut then break; Q.NextXCut:= Q.NextXCut + 1 endloop; L:= L (Q.NextXCut, Q.Width, Q.NextXCut, 1) (Q.Length - Q.NextXCut, Q.Width, Q.NextXCut, 1); 1 Q.NextXCut:= Q.NextXCut + 1; end; Denne rutine kalder yderligere y_cut: procedure y_cut; begin loop if Q.NextYCut > Q.Width div 2 then begin null_cut; return; end; if Q.NextXCut normalycut then break; Q.NextYCut:= Q.NextYCut + 1 endloop; L:= L (Q.Length, Q.NextYCut, 1, Q.NextYCut) (Q.Length, Q.Width - Q.NextYCut, 1, Q.NextYCut); 2 Q.NextYCut:= Q.NextYCut + 1; end; som igen kalder null_cut: procedure null_cut; begin L:= L (Q.Length, Q.Width, 0, Q.NextYCut); 3 Q.NextXCut:= 0; end; 1 Ved klippemønstergenerering skal også oplysninger om de to nye rektanglers placering gemmes i L. For det førstes vedkommende drejer det sig naturligvis om samme placering som det oprindelige (Q.x_location, Q.y_location). For det andets vedkommende vil det dreje sig om (Q.x_location + Q.NextXCut, Q.y_location). 2 Ved klippemønstergenerering skal også oplysninger om de to nye rektanglers placering gemmes i L. For det førstes vedkommende drejer det sig naturligvis om samme placering som det oprindelige (Q.x_location, Q.y_location). For det andets vedkommende vil det dreje sig om (Q.x_location, Q.y_location + Q.NextYCut). 3 Ved klippemønstergenerering skal også oplysninger om rektanglets placering lagres i L. Da der kun er tale om et rektangel, bliver placeringen naturligvis (Q.x_location, Q.y_location).