GeeksforGeeks

forudsætninger :

• rekursion
• Kompleksitetsanalyse

Backtracking er en algoritmisk teknik til at løse problemer rekursivt ved at forsøge at opbygge en løsning trinvist, et stykke ad gangen, fjerne de løsninger, der ikke opfylder problemets begrænsninger på ethvert tidspunkt (efter tid henvises her til den forløbne tid, indtil de når et hvilket som helst niveau af søgetræet).

ifølge definitionen,

Backtracking kan defineres som en generel algoritmisk teknik, der overvejer at søge i enhver mulig kombination for at løse et beregningsproblem.

der er tre typer problemer i backtracking–

1. Beslutningsproblem-i dette søger vi efter en gennemførlig løsning.
2. optimeringsproblem – i dette søger vi efter den bedste løsning.
3. Optællingsproblem – i dette finder vi alle mulige løsninger.

Hvordan finder man ud af, om et problem kan løses ved hjælp af Backtracking?

generelt kan ethvert begrænsningstilfredshedsproblem, der har klare og veldefinerede begrænsninger for enhver objektiv løsning, der trinvist bygger kandidat til løsningen og opgiver en kandidat (“backtracks”), så snart det bestemmer, at kandidaten umuligt kan afsluttes til en gyldig løsning, løses ved Backtracking. Imidlertid kan de fleste af de problemer, der diskuteres, løses ved hjælp af andre kendte algoritmer som dynamisk programmering eller grådige algoritmer i logaritmisk, lineær, lineær-logaritmisk tidskompleksitet i rækkefølge efter inputstørrelse og overskygger derfor backtracking-algoritmen i enhver henseende (da backtracking-algoritmer generelt er eksponentielle i både tid og rum). Der er dog stadig et par problemer, der kun har backtracking-algoritmer til at løse dem indtil nu.

overvej en situation, at du har tre kasser foran dig, og kun en af dem har en guldmønt i den, men du ved ikke hvilken. Så for at få mønten skal du åbne alle boksene en efter en. Du markerer først det første felt, hvis det ikke indeholder mønten, bliver du nødt til at lukke det og markere det andet felt og så videre, indtil du finder mønten. Dette er, hvad backtracking er, det er at løse alle underproblemer en efter en for at nå den bedst mulige løsning.

overvej nedenstående eksempel for at forstå Backtracking-tilgangen mere formelt,

givet en forekomst af ethvert beregningsproblem og data svarende til forekomsten er alle de begrænsninger, der skal opfyldes for at løse problemet, repræsenteret af . En backtracking-algoritme fungerer derefter som følger:

algoritmen begynder at opbygge en løsning, startende med et tomt løsningssæt . S = {}

1. Tilføj til det første træk, der stadig er tilbage (alle mulige træk tilføjes til en efter en). Dette opretter nu et nyt undertræ i algoritmens søgetræ.
2. Kontroller, om opfylder hver af begrænsningerne i .
   • Hvis ja, så er undertræet “kvalificeret” for at tilføje flere “børn”.
   • ellers er hele undertræet ubrugeligt, så gentager sig tilbage til trin 1 ved hjælp af argument .
3. i tilfælde af “berettigelse” af det nydannede undertræ , gentages tilbage til trin 1 ved hjælp af argument .
4. hvis kontrollen for returnerer, at det er en løsning for hele dataene . Output og afslutte programmet.
   hvis ikke, skal du returnere, at ingen løsning er mulig med den nuværende og dermed kassere den.

forskel mellem rekursion og Backtracking:

i rekursion kalder funktionen sig selv, indtil den når en basissag. I backtracking bruger vi rekursion til at undersøge alle mulighederne, indtil vi får det bedste resultat for problemet.

pseudokode til Backtracking :

1. Rekursiv backtracking løsning.

void findSolutions(n, other params) : if (found a solution) : solutionsFound = solutionsFound + 1; displaySolution(); if (solutionsFound >= solutionTarget) : System.exit(0); return for (val = first to last) : if (isValid(val, n)) : applyValue(val, n); findSolutions(n+1, other params); removeValue(val, n);

2. Find ud af, om der findes en løsning eller ej

boolean findSolutions(n, other params) : if (found a solution) : displaySolution(); return true; for (val = first to last) : if (isValid(val, n)) : applyValue(val, n); if (findSolutions(n+1, other params)) return true; removeValue(val, n); return false;

lad os prøve at løse et standard Backtracking-problem, n-Dronning-Problem.
N-Dronningen er problemet med at placere n-skakdronninger på et n-skakbræt, så ingen to dronninger angriber hinanden. For eksempel er følgende en løsning til 4 Dronning problem.

den forventede output er en binær matrice, der har 1s for de blokke, hvor dronninger er placeret. For eksempel er følgende outputmatricen for ovenstående 4 dronningopløsning.

{ 0, 1, 0, 0}{ 0, 0, 0, 1}{ 1, 0, 0, 0}{ 0, 0, 1, 0}

Backtracking algoritme: ideen er at placere dronninger en efter en i forskellige kolonner, startende fra kolonnen længst til venstre. Når vi placerer en dronning i en søjle, kontrollerer vi for sammenstød med allerede placerede dronninger. I den aktuelle kolonne, hvis vi finder en række, hvor der ikke er nogen sammenstød, markerer vi denne række og kolonne som en del af løsningen. Hvis vi ikke finder en sådan række på grund af sammenstød, går vi tilbage og returnerer FALSK.

1) Start in the leftmost column2) If all queens are placed return true3) Try all rows in the current column. Do following for every tried row. a) If the queen can be placed safely in this row then mark this as part of the solution and recursively check if placing queen here leads to a solution. b) If placing the queen in leads to a solution then return true. c) If placing queen doesn't lead to a solution then unmark this (Backtrack) and go to step (a) to try other rows.3) If all rows have been tried and nothing worked, return false to trigger backtracking.

du kan henvise til artiklen om Backtracking | Set 3 (N Dronning Problem) for fuldstændig gennemførelse af ovenstående tilgang.
flere Backtracking problemer:

• Backtracking / Set 1 (ridderens tour problem)
• Backtracking / Set 2 (rotte i en labyrint)
• Backtracking / Set 4 (delmængde Sum)
• Backtracking / Set 5 (m Farvelægning Problem)
• –> Klik her for mere