1. Problem Solving: Brute Force Approaches

2. Brute Force Approaches (aka Complete Search)
Basic idea: try out everything to find the best.
Sometimes, this is the only reasonable solution
Given an unsorted list of numbers, find the max/min.
Only option is to look at each number.
Sometimes, the brute-force approach is good enough
Especially when sizes are not too large, or time is not an issue
e.g. if checking n! different options, if n is 3 or 4, it might be fine to enumerate them.
Often, the brute-force approach is the easiest to implement
Unless you expect time to be an issue (which it often is…), it’s a good way to start
Solving via brute force ensures you understand the problem and know a way to find a solution
If you know a brute force solution is correct, you can use it as a check on your faster solution

3. Basic ways to approach brute force
Iterative vs. recursive
Iterative: loop through to generate all possible combinations
Sometimes will need many loops
Recursive: Make choices in order, generating next state
Then use “backtracking” to return to previous state and pick next choice
Generative vs. filtered
Generators: generate the possible answers – the good ones
Often a recursive definition is better, here
Filtered: generate all answers and choose valid ones

4. Common Themes to Brute-Force Approaches
Pruning
When exploring an option, quit that example as soon as you know it can’t work.
Bounds Limitations
Check the limitations on sizes of input, or other factors
This can drastically reduce the search space of possible options

5. Iterative approaches Loop through all options, testing each
Example: find all pairs of numbers where X is c times Y, and X and Y are 5-digit numbers, using all digits from 0-9
Multiple loops
Example: enumerate all subsets of 6 numbers from a larger collection; use 6 nested loops
Limit range of search
If x2+y2+z2 = C, then x, y, z must have absolute value < sqrt(C), etc.
Keep flag to stop loops early (pruning)
Generating all permutations
Example: For 8 moviegoers, what seating options in a row meet all of 20 conditions (setting limits about distance apart/near)
Subset-sum
Generate all subsets, then check those
n items, 2n possible subsets; possibly viable for n<=20

6. Example
Read numbers A, B C, each <= Find distinct x, y, z so that:
x+y+z = A
x*y*z = B
x2+y2+z2 = C
We can limit loops to [-100,100] for each, due to C
We can limit one of these to cube root of B, or [-22,22] at most
We can do fast checks to make sure x, y, z are distinct before doing calculations
Then, just have loops, and check answers.

7. Recursive search
Recursively search for all possible solutions to a problem
Key is to prune away invalid solutions quickly
Classical problem: 8 queens
Find the positions possible for arranging 8 queens on a chessboard so they can’t attack each other
First: note each column must have one queen, so can recurse that way
Check each row for that column to see if valid – if so, place and recurse (for each valid position)
Valid position means not at the same row or on same diagonal as a prior queen
Helps prune away large sections of search space.
Expanded problem: n-queens on larger board
Need faster (e.g. bitfield) storage to identify valid/invalid rows/diagonals.
Notice: 2n-1 left and 2n-1 right diagonals on an nxn board.

8. Tips to improve performance of brute force
Use short-circuiting of if statements to limit checks
Symmetries: Can drastically reduce the search space.
But, can involve a lot of overhead and complicate the code
Pre-compute: When some values can be known ahead of time, precompute and store.
Solve backward: Look at whether the inverse problem is faster
Optimize source code:
First, try to identify the “critical” code
(see next page)

9. Optimizing source code
Use a faster language: C++>Java>Python
Faster I/O:
C++: scanf/printf vs. cin/cout (scanf/printf don’t flush other)
Java: BufferedReader/BufferedWriter vs. Scanner/PrintStream
Use built-in fast sort (e.g. C++ algorithm::sort)
Access 2D arrays in row-major order (for cache coherency)
Use bit manipulations whenever possible
Use low-level structures when you know you don’t need advanced functionality
e.g. arrays vs. vectors, char[] vs. string
Do single allocation of array as a global
Locals avoid passing/copying
Dynamic allocation will take time
Iterative instead of recursive code when possible
Avoid repeated array access – store the data in a variable

10. Brute Force in Book Book references – section 3.2
READ THIS CHAPTER!!!
Examples of basic problem solutions
Generating all permutations
Use the C++ next_permutation algorithm (iterative approach to generating permutations!).
Generating all subsets
Form an n-bit bitmask (integer), then iterate through numbers