Problem-solving is one of the oldest sciences and is used in every industry and our personal lives. Since problem-solving is so ubiquitous, every industry has developed a model to perform these problem-solving activities more structured way. Some of the older and classic models are PDCA (plan-do-check-act) or DMAIC (define, measure, analyze, improve and control). It is noteworthy that there is some problem dissemination analysis in all these models and breaking down the problem. A doctor or a
medical professional or an accountant may be working in two very different fields, but interestingly, the problem-solving paradigm which they follow will be similar if not identical.
In this article, I will list some basic problem-solving paradigm or strategies for problem-solving in general. I will use classic puzzles and games to explain the fundamental aspects of some of the strategies. Although the problem-solving techniques are more relateable to computer science professionals, they can be approved and applied by any professional.
- Study and identify the constraints
Lack of identification of constraints is a widespread problem even in an institution that follows meticulous problem-solving steps. Part of the problems may be related to insufficient research or data and the overall avoidance of problems. For example, instead of focusing effort and energy on problem-solving, intuition might transfer or sub-contract the problem part. However, fortunately, most of the problems in the real world can be solved by proven tested and tried methods.
The first step of every successful problem-solving endeavor begins with getting the complete information and facts on the problem's constraints and limitations. In fact, most modern operations research, decision problems, and optimization theories are based on constraints satisfaction problems. Whether using a complicated search algorithm or a state-of-the-art artificial intelligence model, failure to identify intricate limitations can lead to disaster.
2. Abstract away parts of the problems
One of the most fundamental problem-solving paradigms is solving problems by analogy. Basically, the idea goes like this. Suppose we are interested in a particular solution to problems. Instead of solving the problem in that particular setting, it's best to abstract away the key ideas of the problem and create a model problem, solve the problem, and then try it on the particular solution. The abstract solution can be parametrized, converting it to a general solution for later problems.
Let’s take an example puzzle for illustration. Most people have heard of the classic crossing the river problem. Essentially we have four entities that need to be ferried across the river. In our case, consider a man, a fox, a chicken, and a bag of corn. The constraints of the problems are generally defined as follows:
- The farmer cannot leave the fox and chicken together because the fox will eat the chicken.
- The farmer cannot leave the chicken and corn together because the chicken will eat the corn.
- The farmer cannot have more than one entity in his boat at a given point.
Technically speaking, this is a bounded search problem that can be solved by techniques such as breadth-first search, etc. The overall solution is essential:
- Transport chicken to the other side
- Transport fox to the other side
- Transport chicken back to the initial side — TRICK step
- Transport sack of corn
- Transport chicken finally
Most people struggle with the 3rd step because initial constraints of the problems are generally left vague purposefully. To solve it, we can convert the assumptions of the problem into a more generalized statement:
- Operation: Row the boat at each iteration from one shore to another
- Operation: If the boat is empty, load an item
- Operation: If the boat is not empty, then unload the item
Once we have written the rules of this famous puzzle into a set of understandable computer operations, we can use a range of different search algorithms which can be implemented.
3.Solve a simple problem and build heuristics
Sometimes we have large or overwhelming problems in scope or nature which appear hard to solve at first.
Since the scope of the problem is large, we do not have sufficient rules or heuristics, and we rely on brute force methods or less efficient problem-solving methods. The solution is to solve a part of a smaller problem and train and build heuristics and rules that will help solve the larger problems. This is similar to how initially players train on smaller rubric cubes of 3 by 3 and move on to larger ones after they have made some insights into the problem.
4.Solve the more constrained part first
The larger number of constraints in a problem space reduces the solution space and actually makes problem-solving faster for that particular region. Hence it might be a good strategy to look for such areas in problem domains.
Sudoku is a famous logic game generally consisting of nine big blocks in which each block has nine further sub-blocks. Each sub-block has a number associated with it from 1 to 9, and the goal is to ensure each big block does not have any repeating numbers. Each column and each row does not repeat numbers. Obviously, it’s a great game to understand constraints since most are explicitly told upfront. Each game board is provided with some filled boxes, and the player has to fill each box with all the numbers from 1 to 9.
Sudoku players, beginners, or professionals unsurprisingly and perhaps instinctively always go for blocks where most of the numbers are already provided. Since the greater number of initial constraints limit the search area and space and allow for quicker solutions. Even in professional fields such as project management, the critical path of a schedule of works is solved first to allow planners more time to play and test with other schedules which have slack times.
5. Some plan is always better than no plan
It is often stated that no plan survives first enemy contact, but plans are beneficial even when in unknown situations. Problem-solving is an extremely iterative process in which we continuously go back and check our constraints and limitation. Although most plans are generally superseded with new approaches, it is better to have some baseline plans or heuristics than a pure brute force search.
6. Divide and Conquer
Perhaps the best-known approach in computer science is generally dividing the problem up into subproblems and solving each subproblem to solve the overall more efficiently. Many of the primary and core sorting and searching algorithms rely on this approach.
We actually use this approach even in everyday life. The sections of library rooms and bookshelves are divided by sections so that the problem of search for a title can be divided. Even in our filing cabinets, we label files either alphabetically or by dates but never randomly.
7. Reduce the Problem
Sometimes it is best to reduce a problem we cannot solve by adding or removing constraints and building logic. For example, for a complicated 4-dimensional trajectory path problem, it is best to start with a two-dimension model of the complicated issues and try solving them more efficiently. Another simple way of solving problems is to first reduce a non-linear complex relationship to a more straightforward linear model and generalize the problem.
8. Always look for analogies
Besides converting the problem to a more abstract one, it is always best to convert the issues into a more familiar form or related problems where some standard solutions exist. We can then take these general forms and plug them into the problem-specific constraints to build a unique solution.
