A Brief Introduction About Backtracking Algorithm.

In Backtracking, we start just one piece at a time, removing those solutions that fail to satisfy the regularity of the matter at any purpose of your time.

Three kinds of issues in backtracking -

1. Decision drawback - during this, we have a tendency to look for a possible answer.
2. optimization drawback - during this, we have a tendency to look for the simplest answer.
3. Enumeration drawback - during this, we discover all the possible solutions.

How to verify if a Prob may be solved victimization Backtracking? - 

Every constraint satisfaction drawback that has clear and well-defined constraints on any objective answer, that incrementally builds candidate and abandons a candidate (“backtracks”) as before long because it determines that the candidate cannot presumably be completed to a sound solution, may be solved by Backtracking. However, most of the issues that are mentioned, are often resolved exploitation alternative illustrious algorithms like Dynamic Programming or Greedy Algorithms in index, linear, linear-logarithmic time quality so as of input size, and thus, outshine the backtracking rule in each respect (since backtracking algorithms are usually exponential in each time and space). However, a couple of issues still stay, that solely have backtracking algorithms to unravel them hitherto.

Consider the below example to know the Backtracking approach additional formally,

Given associate degree instance of any process downside P and knowledge D similar to the instance, all the constraints that require to be glad so as to resolve the matter ar delineate by C. A backtracking formula can then work as follows:

The formula begins to create up an answer, beginning with associate degree empty resolution set S. S = {}

1. Add to S the primary move that's still left (All attainable moves are additional to S one by one). This currently creates a brand new sub-tree s within the search tree of the formula.
2. Check if S+s satisfies each of the constraints in C.
If Yes, then the sub-tree s is “eligible” to feature additional “children”.
Else, the complete sub-tree s is useless, therefore recurs back to step one victimization argument S.
3. In the event of “eligibility” of the fresh shaped sub-tree s, recurs back to step one, victimization argument S+s.
4. If the check for S+s returns that it's an answer for the complete knowledge D. Output and terminate the program.
If not, then come back that no resolution is feasible with the present s and thus discard it.

Pseudo Code for Backtracking :

1. Recursive backtracking solution.

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. Finding whether a solution exists or not.

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;