Backtracking in JavaIntroductionBacktracking is an algorithmic technique that utilizes a bruteforce approach to find the desired solution. Put simply, it exhaustively tries all possible solutions and selects the optimal one. The term backtracking refers to the process of retracing one's steps and exploring other alternatives if the current solution is not viable. As a result, recursion is employed in this approach. Backtracking is particularly useful for solving problems with multiple solutions. Backtracking is an algorithmictechnique for solving problems recursively by trying to build a solution incrementally, one piece at a time, removing those solutions that fail to satisfy the constraints of the problem at any point of time (by time, here, is referred to the time elapsed till reaching any level of the search tree) There are three types of problems in backtracking
How to determine if a problem can be solved using Backtracking?Generally, every constraint satisfaction problem which has clear and welldefined constraints on any objective solution, that incrementally builds candidate to the solution and abandons a candidate ("backtracks") as soon as it determines that the candidate cannot possibly be completed to a valid solution, can be solved by Backtracking. However, most of the problems that are discussed, can be solved using other known algorithms like Dynamic Programming or Greedy Algorithms in logarithmic, linear, linearlogarithmic time complexity in order of input size, and therefore, outshine the backtracking algorithm in every respect (since backtracking algorithms are generally exponential in both time and space). However, a few problems still remain, that only have backtracking algorithms to solve them until now. Consider a situation that you have three boxes in front of you and only one of them has a gold coin in it but you do not know which one. So, in order to get the coin, you will have to open all of the boxes one by one. You will first check the first box, if it does not contain the coin, you will have to close it and check the second box and so on until you find the coin. This is what backtracking is, that is solving all subproblems one by one in order to reach the best possible solution. Consider the below example to understand the Backtracking approach more formally Given an instance of any computational problem P and data D corresponding to the instance, all the constraints that need to be satisfied in order to solve the problem are represented by C . A backtracking algorithm will then work as follows: The Algorithm begins to build up a solution, starting with an empty solution set S. S = {} Add to S the first move that is still left (All possible moves are added to S one by one). This now creates a new subtree s in the search tree of the algorithm. Check if S+s satisfies each of the constraints in C . If Yes, then the subtree s is eligible to add more children. Else, the entire subtree s is useless, so recurs back to step 1 using argument S . In the event of eligibility of the newly formed subtree s , recurs back to step 1, using argument S+s . If the check for S+s returns that it is a solution for the entire data D . Output and terminate the program. If not, then return that no solution is possible with the current s and hence discard it. Pseudo Code for Backtracking : Recursive backtracking solution. NQueen Problem.Let us try to solve a standard Backtracking problem, NQueen Problem. The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack each other. For example, following is a solution for 4 Queen problem. The expected output is a binary matrix which has 1s for the blocks where queens are placed. For example, following is the output matrix for the above 4 queen solution. { 0, 1, 0, 0} { 0, 0, 0, 1} { 1, 0, 0, 0} { 0, 0, 1, 0} Backtracking Algorithm: The idea is to place queens one by one in different columns, starting from the leftmost column. When we place a queen in a column, we check for clashes with already placed queens. In the current column, if we find a row for which there is no clash, we mark this row and column as part of the solution. If we do not find such a row due to clashes then we backtrack and return false.
NQueensBacktracking.java Output: 0 0 1 0 0 2 0 1 3 1 0 0 2 0 1 0 Time complexity = O(N!) The time complexity of the backtracking algorithm for the NQueens problem is O(N!). This is because the algorithm needs to explore all possible placements of N queens on the board, and there are N! possible placements. Space complexity = O(N*N) The space complexity of the backtracking algorithm for the NQueens problem is O(N^2). This is because the algorithm needs to store a representation of the board, which requires a 2D array of size N x N. Additionally, the algorithm needs to store a stack to keep track of the recursive calls, which requires O(N) space. ConclusionBacktracking is a powerful algorithm that can be used to solve a wide variety of problems. It is often used to solve problems where the solution space is large or complex. Here are some examples of problems that can be solved using backtracking
Backtracking is a versatile algorithm that can be used to solve a variety of problems. It is often used when other algorithms, such as brute force search, would be too slow or impractical.
Next TopicComparing Doubles in Java
