1.2.5. Techniques for Problem Solving

An important part of problem solving in any domain and in particular algorithms is the art of modelling the problem at a suitable level of detail. In most algorithms that we will see we need to find a suitable mathematical model.

This chunk introduces the importance of modeling problems accurately when working on algorithms. It emphasizes that before solving any problem, one must create a mathematical representation of it to better understand its structure and complexities.

Think of it as planning a road trip. Before you start driving, you might want to draw a map detailing the route, potential stops, and any obstacles you might encounter. This plan helps you navigate the journey more effectively.

We need a way of representing the concepts of these models in our algorithm. For this, we need appropriate data structures. And of course typically in order to solve a problem we need to break it down into manageable sub problems.

This chunk discusses the necessity of data structures for representing the mathematical models and stresses the process of breaking down complex problems into smaller, more manageable sub-problems. This makes the overall solution simpler and more efficient.

Imagine baking a cake. Instead of trying to combine all ingredients at once, you break it down: first mix the dry ingredients, then the wet ones, and finally combine them. Handling each step separately simplifies the entire baking process.

Over the course of time, many generic techniques have been developed to solve the large number of problems. And we will see examples of how these techniques can be applied to very standard problems that we come across repeatedly.

In this chunk, the speaker highlights that there are established methodologies for approaching various problems. These techniques not only streamline the problem-solving process but also help in handling common problems that appear in different contexts.

Consider using a specific recipe every time you want to make cookies. This recipe is a standard technique that helps you consistently produce good results, regardless of the type of cookies being made.

Among the techniques are divide and conquer. Where, we break up the problem into individual components which do not overlap with each other and then combine these solutions in order to get the solution for the overall problem.

This chunk introduces the 'divide and conquer' strategy, which involves splitting a larger problem into smaller, independent parts, solving each part individually, and then combining the solutions to form the overall solution. This technique is particularly effective for optimizing problem resolution.

Consider assembling a large piece of furniture that comes with many parts. Instead of tackling the entire assembly at once, you might first lay out all parts, categorize them, and assemble them one section at a time. Once all sections are complete, you can combine them into the final product.

In some cases, we can identify a strategy which looks at the local state of the problem and chooses an optimal path and arrives at the final solution without having to look at all possibilities. These kind of greedy algorithms are there.

This chunk explains 'greedy algorithms', which are designed to make the best immediate choice without considering the larger context. This can lead to a fast solution that is often efficient, though not always the most optimal in every situation.

Imagine you’re making a series of purchases and each time you choose the item with the highest discount at that moment. This 'greedy' choice saves you money quickly, but you may end up missing out on a better deal if you'd looked at all options.

When greedy does not work, we need a systematic way of exploring all the possibilities and choosing the best one. In this process, sometimes we have to discard overlapping problems and make sure that we do not waste fully recomputed things. So, this is covered by the concept of dynamic programming.

This chunk introduces 'dynamic programming', which is a more systematic approach used when greedy algorithms fail to find a global optimum. This technique tackles overlapping sub-problems and ensures that calculations are not repeated, thereby saving computation time.

Think of planning a road trip with multiple destinations. Instead of calculating each leg of the trip independently which can lead to repetitive calculations (like re-evaluating routes), dynamic programming lets you solve for all points of interest with efficiency, by reusing information from previous calculations.

--