Problem Solving: Brute Force Approaches

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

3. Basic ways to approach brute force • Iterative vs. recursive • Iterative: loop through to generate all possible combinations • Sometimes will need many loops • Recursive: use “backtracking” to choose next, repeatedly • 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. Iterative approaches • Loop through all options, testing each • Example: find all pairs of numbers where X is c times Y, and X and Y use are 5-digit numbers, using all 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

5. Example • Read numbers A, B C, each <= 10000. 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.

6. 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.

7. Tips to improve performance of brute force • Use short-circuiting of if statements to limit checks • Pruning: identify early when there is an infeasible branch • Remember that sometimes you can bound quality of a branch • 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)

8. 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 stort (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

9. Brute Force in Book • Book references – section 3.2 • 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