It all boils down to depth-first traversal of n-ary trees.
Consider this diagram:
Problem := Any statement that requires a solution.Solution-path := A series of steps that need to be followed to arrive at the solution. The solution may or may not be attained by following a solution-path.
Node := A point in the solution path from which one or more steps could be followed to arrive at the solution.
Backtracking := If a solution-path leads to a dead end or not to the desired solution, we backtrack to a previous node, and then follow a different solution-path.
When I see the problem, i take solution-path 1 to see if that could lead to the answer. After reaching NodeA in path 1, i may have to make a choice of steps to follow. This causes more solution-paths to be generated. At some time, i know i've reached a dead-end, and backtrack to a previous node. Take a different solution path this time. hgoes on till I arrive at the solution. Sometimes more than one solution has to be found out, and the best(optimal/efficient) of them will have to be selected. So the whole tree will have to be traversed.
Now consider if we solve this informally. It is fine (and recommended) if the tree is small enough (low value of n). We can mentally keep track of the paths, and even without a tree structure in mind, strike off the wrong paths, and thus arrive at the best solution.
When n is large, i feel that we have to consciously put on paper the tree, traverse each branch recursively and solve it. In the case of trial and error problem solving methods, this is an extremely important step. Write down the problem. Solution Path one. Solution Path two. where they differ. Point of branching. And while checking if the path leads to a solution, backtrack to an earlier node, continue from there.
All these are old school stuff, but I believe the application of this to real world problems will lead to efficient problem solving.
