Backtracking som løsningsmetode

Backtracking

Backtracking som løsningsmetode Backtracking brukes til å løse problemer der løsningene kan beskrives som en sekvens med steg eller valg Kan enten finne én løsning eller alle løsninger Bygger opp løsningen ett steg om gangen Prøver for hver steg som er gjort alle mulige steg videre Hvis vi ser at et steg ikke kan lede til en løsning (avskjæring), tar vi et steg tilbake (backtracking) og prøver i stedet neste mulige steg

Backtracking og effektivitet Rå kraft (brute force) algoritmer: Genererer alle mulige sekvenser av steg som kan være en løsning For hver av de mulige løsningene: Sjekk om den er korrekt løsning Ressurskrevende, ubrukelig for større problemer Algoritmer med backtracking: Er ofte basert på en rå kraft algoritme Stopper oppbyggingen av en mulig løsning når vi ser at den ikke kan være korrekt Effektiviteten avhenger av hvor smart/tidlig vi gjør denne avskjæringen av løsninger

Backtracking og rekursjon Backtrackingsalgoritmer er av natur rekursive: Vi tar et og et steg mot en fullstendig løsning I hvert steg løser vi det samme problemet Problemstørrelsen reduseres for hvert steg Bunnen i rekursjonen: Vi har bygget opp en komplett løsning og det er ikke flere steg igjen å ta

Problemeksempler Typiske problemer som kan løses rekursivt med bruk av backtracking: Finne en 'korrekt' rekkefølge: Dronningproblemet Fargelegging av kart Fordeling av ressurser iht. behov/ønsker Labyrinter, kryssord, sudoku, brettspill Rutevalg: Finne beste vei gjennom et nettverk

Enkelt eksempel: En labyrint Kvadratisk rutenett der noen ruter er blokkerte Starter i øvre venstre hjørne, prøver å finne vei til nedre venstre hjørne Fire muligheter i hvert steg: Høyre, ned, venstre, opp Avskjæring: Går ikke ut av labyrinten Går ikke til blokkerte ruter Går ikke til ruter som er besøkt tidligere

Datastruktur for labyrinten Før algoritmen for å finne en vei starter: Bruker en todimensjonal, globalt tilgjengelig tabell med heltall, med verdiene 1 (fri) og 0 (stengt) Spør bruker om størrelse på labyrinten og prosentandelen blokkerte ruter Trekker tilfeldig hvilke ruter som skal være blokkert, slik at prosentandelen blir omtrent riktig Mens algoritmen utføres: Markerer oppsøkte ruter med verdien 2 i tabellen Tar vare på veien, ved at ruter som ligger på funnet vei markeres med verdien 3 i tabellen

Rekursiv implementasjon Merker etterhvert av besøkte ruter i global tabell Bunn i rekursjonen når vi kommer til nedre høyre hjørne Fire rekursive kall med flytt til hver av naborutene (høyre, ned, venstre opp) hvis: Naboruten finnes, er fri og ikke tidligere besøkt Stopper rekursjonen med en gang en vei er funnet Merker rutene på evt. funnet vei når rekursjonen trekker seg tilbake Java-kode

Oblig. 2: Springerproblemet Springer: 2 frem, 1 til siden Starter med en springer i en gitt posisjon på et n x n brett Problem: Finne en måte å flytte springeren rundt på sjakkbrettet, slik at den er innom hver rute en og bare en gang en springertur Finnes ikke alltid løsning, avhenger av startposisjon og størrelsen på brettet

Springerproblemet og backtracking Problemet kan løses på en tilsvarende måte som for labyrinten: Bruk en global tabell til å lagre hvilke ruter som er oppsøkt (og et par andre globale variable som holder rede på hvor langt vi har gått og flyttene som er gjort) Må merke en rute som ubrukt igjen når vi backtracker Prøv alle 8 steg videre fra hver posisjon Ikke gå utenfor brettet, ikke oppsøk samme rute flere ganger Problemet er løst etter n² steg (alle ruter besøk) Bruk gjerne Java-koden for labyrinten som utgangspunkt for løsningen

Litt kombinatorikk Kombinatorikk: Systematiske metoder og formler for å telle opp antall mulige måter som vi kan gjennomføre steg-for-steg prosesser på Eksempler: Antall mulige utfall av en LOTTO-trekning På hvor mange forskjellige måter kan vi få f.eks. en flush utdelt i poker? Hvor mange forskjellige oppstillinger av n dronninger kan vi lage på et n x n sjakkbrett? Kjennskap til et par grunnleggende formler fra kombinatorikken er nødvendig for å kunne forstå kompleksiteten i en del backtrackingproblemer

Multiplikasjonsprinsippet En prosess består av å gjøre n (del)valg i rekkefølge I hvert delvalg har vi ki ulike alternativer, i = 1, 2,, n Hele prosessen kan da utføres på: k 1 k 2 k 3 k n-1 k n ulike måter

Mult.prinsippet: Et eksempel Velge antrekk (bukse og genser) n = 2 delvalg k1 = 3 bukser k2 = 2 gensere Totalt: k 1 k 2 = 3 2 = 6 mulige ulike antrekk

Et eksempel til: Svenske bilskilt Vanlige svenske registreringsnumre for biler består av tre bokstaver og tre siffer (0 9) Bokstavene Q, V, Å, Ä, Ö brukes ikke, 24 bokstaver kan velges for bilskilt Det er 91 tre-bokstavskombinasjoner som er forbudt å bruke (så svenskene skal slippe å kjøre rundt med SPY, K*K o.l. på bilene sine :-)

Antall mulige ulike svenske bilskilt n = 6 delvalg Tre valg for hver av de tre bokstavene, 24 ulike muligheter i hvert valg: k 1 = k 2 = k 3 = 24 Tre valg for hvert av de tre sifferne, 10 ulike muligheter i hvert valg: k 4 = k 5 = k 6 = 10 Totalt: 24 24 24 10 10 10 (91 10 10 10) = 13 733 000 ulike vanlige svenske bilskilt som kan lages

Permutasjoner Har n objekter som alle er ulike Objektene skal stilles opp i en eller annen rekkefølge (ikke nødvendigvis sortert) Det å bestemme en rekkefølge kan sees på som å nummerere objektene fra 1 til n En slik nummerering av n objekter kalles for en permutasjon av objektene Å endre rekkefølger kalles å permutere (eller å stokke om, bytte om) I mange backtrackingsproblemer vil løsningen være en permutasjon som oppfyller visse krav

Permutasjoner, noen eksempler Alle 6 permutasjoner av 123: 123 132 213 231 312 321 Alle 24 permutasjoner av ABCD: ABCD ABDC ACBD ACDB ADBC ADCB BACD BADC BCAD BCDA BDAC BDCA CABD CADB CBAD CBDA CDAB CDBA DABC DACB DBAC DBCA DCAB DCBA

Antall mulige permutasjoner Kan bruke multiplikasjonsprinsippet til å regne ut antall mulige ulike permutasjoner av n objekter En permutering er en prosess med n delvalg: Velg nr 1: n muligheter Velg nr 2:... n - 1 muligheter Velg nr n - 1: 2 muligheter Velg nr n: 1 mulighet Total antall mulige permutasjoner av n objekter: n (n - 1) (n - 2) 3 2 1 = n! (n-fakultet)

Antall permutasjoner vokser raskt 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 11! = 39916800 12! = 479001600 13! = 6227020800 14! = 87178291200 15! = 1307674368000 16! = 20922789888000 17! = 355687428096000 18! = 6402373705728000 19! = 121645100408832000 20! = 2432902008176640000

Program for å lage og skrive ut alle permutasjoner av tallene 1, 2,, n Lagrer alle permutasjoner som genereres, i en global heltallsarray p av lengde n Permutasjonene bygges opp systematisk og rekursivt, ved at vi etter tur setter alle tallene inn som nummer en, deretter som nummer 2 osv. Tar vare på hvilke av tallene 1, 2,.., n som allerede er brukt i en permutasjon, i en global boolsk array brukt, slik at vi ikke setter inn samme tall to ganger

Rekursiv algoritme Posisjonen index i arrayen p er parameter i rekursjonen: Hvis index == n Ferdig, skriv ut permutasjon, returnér For i = 1, 2,, n Hvis!brukt(i) brukt[i] = true p[index] = i Lag alle perm. f.o.m. posisjon index+1 brukt[i] = false Se Java koden

Dronningproblemet 8 (n) dronninger skal plasseres på et 8 x 8 (n x n) sjakkbrett, slik at ingen av dem kan slå/nå hverandre En dronning kan beveges fra ruten den står på, i begge retninger horisontalt, vertikalt og langs de to diagonalene

To løsninger for n = 8

Antall løsninger for voksende n n 1 1 2 0 3 0 4 2 5 10 6 4 7 40 8 92 9 352 10 724 n 11 2 680 12 14 200 13 73 712 14 365 596 24 227 514 171 973 736 25 2 207 893 435 808 352 26 22 317 699 616 364 044

Løsning av dronningsproblemet Kan betraktes som et steg-for-steg problem I hvert steg setter vi ut én dronning Tidsforbruket for en algoritme som løser dronningproblemet avhenger av: Størrelsen på sjakkbrettet, n Hvor tidlig vi avskjærer utbyggingen av en løsning, dvs. tar vekk sist utplasserte dronning og går tilbake til den forrige

Rå kraft -løsning, versjon 0.1 Prøv med alle mulige ledige ruter i hvert steg Test om hver mulig utplassering av n dronninger er en løsning Antall løsninger som må lages og testes for n = 8 (multiplikasjonsprinsippet): 64 63 62 61 60 59 58 57 = 4 426 165 368 For generell n: n 2 (n 2-1) (n 2-2) (n 2 -n+2) (n 2 -n+1) Ubrukelig for n > 5 (sjekk testprogram)

Rå kraft - løsning, versjon 0.2 Ikke sett dronninger på samme rad For hver rad: Prøv alle rutene Test om hver mulig utplassering av n dronninger er en løsning Antall løsninger som må lages og testes for n = 8 (multiplikasjonsprinsippet): 8 8 8 8 8 8 8 8 = 8 8 = 16 777 216 For generell n: n n Ubrukelig for n > 8 (sjekk testprogram)

Litt smartere løsning Ikke sett dronninger i samme rad eller kolonne En løsning blir da en permutasjon av 1, 2,, n {4, 7, 3, 8, 2, 5, 1, 6} Antall løsninger som må lages og testes for n = 8: 8 7 6 5 4 3 2 1 = 8! = 40 320 For generell n: n! Får alvorlige problemer for n > 11 (sjekk testprogram)

Enda smartere løsning Bruk programmet for å lage permutasjoner til å bygge opp løsningen rad for rad: Permutasjonene som genereres representerer en løsning som er under utbygging Vil automatisk unngå dronninger i samme rad/kolonne For hver dronning som settes ut i en rad: Sjekk om noen av dronningene som allerede er satt ut ovenfor kan slå denne langs de to diagonalene I så fall: Gå videre til neste ledige kolonne i raden Trenger bare å utvide permutasjonsprogrammet med en funksjon som sjekker de to diagonalene bakover

Backtracking og rekursjon frem til første løsning for n = 8 Se Java-koden