Status check

• Discussion 02: Evaluating implementations/code
• A03 clarification
• A04 posted to be posted soon (today?)
• Exam 1 next week.

A Problem to Solve

Find all combinations of 3 integers between 1 and 4 that sum to 5.

• One way to do this is by brute force...

Determine all combinations

 111 112 113 114   121 122 123 124   131 132 133 134   141 142 143 144
 211 212 213 214   221 222 223 224   231 232 233 234   241 242 243 244
 311 312 313 314   321 322 323 324   331 332 333 334   341 342 343 344
 411 412 413 414   421 422 423 424   431 432 433 434   441 442 443 444

• problem size: range size (1 to 4 = 4) ^ combination length (3 ints) = n^c (4^3 = 64).
• Could generate this by (combination length) * loops (Here: 3 loops)
  • outer loop: row (first digit)
  • middle loop: square (second digit)
  • inner loop: col (third digit)

Sum all combinations

And see which == 5.

 111 112 113 114   121 122 123 124   131 132 133 134 | 141 142 143 144
 211 212 213 214   221 222 223 224 | 231 232 233 234   241 242 243 244
 311 312 313 314 | 321 322 323 324   331 332 333 334   341 342 343 344
|411 412 413 414   421 422 423 424   431 432 433 434   441 442 443 444

• Optimizations possible
  • Example: if the first two values sum to >= 5, no point carrying on in that row.
  • Improve real-world performance, but doesn't change big-O
• This suggests another approach: think of this as a search space problem
  • Use recursion to explore avenues, then stop and backtrack if we hit a dead end.

A backtracking algorithm

find(int[] array, int i):
  if i == array.length:
    return
  sum = sum of array elements up to index i (exclusive)
  for guess from 1 to 4:
    array[i] = guess
    if i == array.length - 1 && sum + guess == 5:
      print array             //found one
      return                  //no more to be found at this i
    else if guess + sum >= 5:
      return                  //dead end
    else:
      find(array, i + 1)      //recurse
  return

• Could you turn this into code?
• Trace for call: find(new array[3], 0)
• (Note: actually reusing same single array throughout as scratch space)

Trace:
find(array=[?,?,?], i=0)
.sum = 0
.guess = 1: 
..find(array=[1,?,?], i=1)
...sum = 1
...guess = 1
....find(array=[1,1,?], i=2)
.....sum=2
.....guess=1
......find(array=[1,1,1], i=3) - return
.....guess=2
......find(array=[1,1,2], i=3) - return
.....guess=3
......find(array=[1,1,3], i=3) 
......print: [1,1,3]
......return
...guess=2
....find(array=[1,2,?], i=2)
.....sum=3
.....guess=1
......find(array=[1,2,1], i=3) - return
.....guess=2
......find(array=[1,2,2], i=3) - return
......print: [1,2,2]
......return
...guess=3
....(and so on...)

Backtracking

• Can think of solutions as forming a tree
• Each path from root to leaf is a complete solution
• Each step along that path is part of the solution
  • Usually use a loop to iterate of each possible next step from the current one
• If a path doesn't pan out, we can abort early (prunes the tree/search space)
• Even if that path is successful, we backtrack and explore the other paths
  • (if we want all solutions)
• For some problems, stop at first solution; in others, you find all solutions.

Variant: All constants as parameters

find(int start, int end, int total, int[] array, int i):
  if i == array.length:
    return
  sum = sum of array elements up to index i (exclusive)
  for guess from start to end:
    array[i] = guess
    if i == array.length - 1 && sum + guess == total:
      print array
      return
    else if guess + sum >= total:
      return
    else:
      find(start, end, total, array, i + 1)
  return

• Now solves for any size combination (array.length), any range of numbers(start, end), and any total.

Variant 2: Return list of solutions

find(int start, int end, int total, int[] array, int i):
  list = new empty list
  if i == array.length:
    return list  //still empty
  sum = sum of array elements up to index i (exclusive)
  for guess from start to end:
    array[i] = guess
    if i == array.length - 1 && sum + guess == total:
      list.add(copy of array)
      return
    else if guess + sum >= total:
      return list  //might be empty
    else:
      sublist = find(start, end, total, array, i + 1)  //recurse
      list.addAll(sublist)
  return list //might be empty

Combo-finding algorithm as Java code

import java.util.ArrayList;

public class ComboSumFinder {
  /** Prints all combos of 3 ints, each between 1 to 4, that add up to 5. */
  public static void main(String[] args) {
    ArrayList<int[]> combos = find(3, 1, 4, 5);
    for (int[] combo : combos) {
      System.out.println(java.util.Arrays.toString(combo));
    }
  }

  /**
   * Returns a list of all combos of the given length, formed of integers
   * between start and end (both inclusive), that add up to total.
   */
  public static ArrayList<int[]> find(int length, int start, int end, int total) {
    return find(start, end, total, new int[length], 0);
  }

  private static ArrayList<int[]> find(int start, int end, int total, 
                                             int[] array, int i) {
    ArrayList<int[]> list = new ArrayList<int[]>();
    if (i == array.length) {
      return list;
    }
    //sum of elements in array up to index i (exclusive)
    int sum = 0;
    for (int j = 0; j < i; j++) {
      sum += array[j];
    }

    //try each value for current array element from start to end
    for (int guess = start; guess <= end; guess++) {
      array[i] = guess;
      if (i == array.length - 1 && sum + guess == total) {
        list.add(java.util.Arrays.copyOf(array, array.length));
        break;
      }else if (guess + sum >= total) {
        return list;
      }else {
        ArrayList<int[]> sublist = find(start, end, total, array, i + 1);
        list.addAll(sublist);
      }
    }
    return list;
  }
}

• This code does rely on some array and ArrayList details we'll get to next time (didn't have time for it today).
• Could be more efficient to have a single list passed as parameter rather than creating one for each recursive call.

Sudoku

..|2. 
2.|.4 
-----
..|4.
3.|..

• Rules. (This is a mini-Sudoku example)
• Again: could produce all possible board combos (starting with all 1s)
  • Eliminate those that don't match the given starting values
  • Eliminate that those are illegal
  • Remainder is solution (maybe more than one)
• Or use backtracking to fill in one square at a time...

Sudoku Algorithm

sudoku(board, row, col):
  if board.isFull:
    return OK
  if (row,col) already set:
    return sudoku(board, next(row,col))  //on to next square
  for guess 1 to 4:
    board.set(row, col, guess)
    if board.checkRow? and board.checkCol? and board.checkSquare?:
      ok? = sudoku(board, next(row,col))
      if ok?:
        return OK
        
  board.unset(row,col)        
  return !OK  //no guess worked here

..|2. 
2.|.4 
-----
..|4.
3.|..

• Try the first two rows + 1 space
• (This is simple, but there are more efficient solutions than this algorithm.)

Many classic backgracking problems

• 8-Queens Problem: Put 8 queens on an 8x8 chessboard such that they don't attack each other
• Generalized to n-queens problem

A04: Maze Problem

• Given a map, how do you get from the Start to the Exit?

  #######
  #    S#
  # # ###
  # #   E
  #######
  

• See 5.6 in textbook
• Will need to return a path (list of directions)
• (We'll talk a bit more about this next time...)

Parameters vs Local variables (1/2)

Similarities:

• both stored on the stack
• both limited to scope of the method

So parameters considered by some to be a subset of local variables.

Parameters vs Local variables (2/2)

Differences:

• parameters declared in method signature; local variables in method body
• parameter always initialized; local variable may not be
• local variable may have smaller scope (such as in if block)
• In Java, officially considered different (in Tutorial)
• In other languages, parameters may be pass-by-reference or pass-by-name, which local variables can never be. Also: default parameter values, static local variables in C, etc.

Loop controls: break

Sometimes important (or just easier) to break out of a loop early:

int[] nums = {1, 5, -2, 10};

//sum all values up to first negative number
int sum = 0;
for (int i = 0; i < nums.length; i++) {
  if (nums[i] >= 0) {
    sum += nums[i];
  }else {
    break;
  }
}
System.out.println("Sum of initial positives only: " + sum);

• Breaks out of enclosing loop (or switch) only
• What if no break; used here? (would get 16, not 6)
• Can usually do without break if you use extra test or variable, though:

  for (int i = 0; i < nums.length && nums[i] >= 0; i++) {
    sum += nums[i];
  }
  

Loop controls: Infinite loops + break

java.util.Scanner keybd = new java.util.Scanner(System.in);
int oneToTen = 0;
while (true) {
  try {
    System.out.print("Enter an int b/w 1 and 10: ");
    oneToTen = keybd.nextInt();
    if (oneToTen >= 1 && oneToTen <= 10) {
      break; //good input
    }else {
      System.out.println("That is not between 1 and 10.");
    }
  }catch (java.util.InputMismatchException e) {
    System.out.println("That is not a number.");
    keybd.nextLine();  //clear input stream
  }
}
//...use oneToTen here...

• Some people don't like this style (loop control is buried somewhere in loop body)
• Others like it because don't need to bother with complicated loop condition
• Can be particularly useful when you have multiple possible loop breaking conditions (ie, 3 different ways loop might end -> breaks in if/else-if/else-if)
• Compromise: a boolean variable that just controls loop, changed inside loop.

Loop controls: More

• Also: continue
• Ability to label loops to break or continue other than most recent containing loop.
• See Tutorial for more.

Summary

• Recursion becomes a valuable tool when you start to use backtracking
• Parameters vs local variables
• break and other looping constructs

Next time...

• Quiz 03 before next class
• We'll review a bit ('cause Exam 1 is next Mon)
• Talk about A04
• Start OOP review