# BACKTRACKING ALGORITHM

--

Use the backtracking algorithm, when you are confused with your life. Rewind the things and analyze them. How it is solved and restart your life again

Anytime you have a problem that is solved by a series of decisions there are chances that you might make a wrong decision and when you realize that you have to backtrack to a place where you made that decision and try something else, that what backtracking is. It is an efficient technique that uses** a brute force approach** to solve algorithm problems. In backtracking, we search depth-first for solutions backtracking to the last valid path as soon as we hit a dead end.

Backtracking decreases the search space since we at this point don’t need to follow down anyways, we know are invalid. This is called **pruning**. We should have the option to test a partial solution: for instance, we can’t track down global optimum utilizing backtracking, since we have no clue if the solution, we’re as of now on can prompt it or not. However, we can, for instance, address Sudoku utilizing backtracking. We can know quickly if our answer so far is invalid by testing if two of a similar number show up in a row, column, or square.

It is helpful to execute a backtracking algorithm by building a tree of decisions being made, called the **state-space tree**. Its root addresses an underlying state before the quest for an answer starts. The nodes of the primary level in the tree address the decisions made for the main segment of an answer, the nodes of the subsequent level address the decisions for the subsequent part, etc. A node in a state-space tree is supposed to be promising in the event that it relates to a somewhat constructed solution that may, in any case, prompt a final solution; else, it is called nonpromising.

Leaves address either nonpromising dead ends or final solutions found by the calculation. In most cases, a state-space tree for backtracking algorithm is developed in the way of depth-first search. In the event that the current node is promising, its child node is generated by adding the principal remaining choices for the following components of the solution, and the preparing moves to this child node. In the event that the current node ends up being nonpromising, the algorithm backtracks to the node’s parent to think about the following conceivable alternative for its last part; if there is no such choice, it backtracks one more level up the tree and so on. At last, if the algorithm arrives at the final solution for the question, it either stops (if only one is required) or keeps looking for other potential solutions.

There are three types of backtracking problems:

- Decision Problem — In this, we search for a feasible solution.
- Optimization Problem — In this, we search for the best solution.
- Enumeration Problem — In this, we find all feasible solutions.

Backtracking can be used in the problems that have clear and very much characterized requirements on any objective solution, that gradually assembles candidate to the solution and forsakes a candidate (“backtracks”) when it confirms that the candidate can’t in any way be finished to a substantial solution. Then again, backtracking isn’t viewed as a streamlined procedure to tackle a problem. It discovers its application when the solution required for an issue isn’t time-limited.

Consider a circumstance that you have three oranges before you and just one of them has a delicious taste however you don’t know which one. Thus, to get that delicious orange, you should peel off every orange individually. You will initially taste the primary orange, on the off chance that it doesn’t taste good, you should leave it as it is and peel the subsequent orange and so on until you find that delicious orange. This is the thing that backtracking is, that is tackling all sub-problems individually to arrive at the most ideal solution.

Consider the beneath instance to comprehend the Backtracking approach,

Given an example of any problem, P1 and data given as D1 comparing to the occasion, every one of the constraints that should be fulfilled to tackle the problem are addressed by C1. A backtracking algorithm will at that point function as follows:

The Algorithm starts to develop an answer, beginning with an unfilled solution set s. s = {}

**Add to s the starting move that is still left (All potential moves are added to s individually). This presently makes another sub-tree st in the search tree of the algorithm.**

2.** Check if s+st fulfills every one of the constraints in C1.**

**On the off chance that Yes, the sub-tree st is “qualified” to add more “children”.**

**Else, the whole sub-tree st is pointless, so repeats back to stage 1 utilizing argument s.**

3.** In case of “qualification” of the recently shaped sub-tree st, repeats back to stage 1, utilizing contention s+st.**

4.** On the off chance that the check for s+st returns that it is an answer for the whole data D1. Output and end the program.**

**Assuming not, return that no solution is feasible with the current st and then delete it.**

Backtracking is most often associated with recursion but the way backtracking happens with the recursive solution is tough to see and makes it difficult to write recursive backtracking solutions.

In recursion, the function calls itself until it arrives at a base case. In backtracking, we use recursion to investigate every one of the prospects until we get the best outcome for the problem.

Few popular problems related to backtracking algorithm are as follows:

- Hamiltonian cycle
- N-Queens problem
- Solving cryptarithmetic puzzles
- The knight’s tour problem
- Rat in a Maze
- m coloring problem
- Magnet Puzzle
- Flight itinerary problem

**N-QUEEN PROBLEM**

In the N-Queen problem, we are given an NxN chessboard and we need to put n queens on the board so that no two queens assault one another. A queen will assault another queen on the off chance that it is put in vertical, horizontal, or diagonal points in its direction.

The binary output with 1’s as queens to the positions are placed:

{0 , 1 , 0 , 0}

{0 , 0 , 0 , 1}

{1 , 0 , 0 , 0}

{0 , 0 , 1 , 0}

we will take a stab at setting the queen into various positions of one row. What’s more, checks on the off chance that it conflicts with the different queen. In the event that current situating of queens if there are any two queens assaulting one another. On the off chance that they are assaulting, we will backtrack to the past location of the queen and change its positions. Furthermore, check the conflict of the queen once more.

ALGORITHM FOR N-QUEEN PROBLEM

# CONCLUSION

Backtracking algorithm is regularly applied to troublesome combinatoric problems for which no effective algorithm for finding, precise solutions potentially exists. It creates all components of the problem state and takes care of each example of a problem in a satisfactory measure of time. Backtracking stays a legitimate and indispensable tool for taking care of different sorts of problems, despite the fact that this present algorithm’s time intricacy might be high, as it might have to investigate every single existing solution.