Programming, problem solving, and algorithms

CPSC 203, 2026 W1

November 5, 2026

Announcements

• Practice Examlet 4 is available.
• Lab 8 (memoization) and POTW 8 (mostly Sudoku validity) due Sunday.
• Project 2 (Game of Life) released, due Monday November 16.
  • Time to get started!
• Next week: No labs, no POTWs, no examlet.
  • Normal lecture on Thursday November 12.
• Feeling overwhelmed? You are not alone!
  • Visit student health services’ mental health resources.

State Space Graphs

Reminder: Rush Hour Game

• \(V\): State of the board / position of all cars / configuration.
• \(E\): Connect two configurations if there is a legal move between them.
• Path is a sequence of legal moves, hopefully leading to a winning configuration.

• We looked at this game last week as an example of a graph.
• This lecture we will explore how to build a game solver using graphs.

Game Graphs: Tic-Tac-Toe

Two players take turns marking a cell in a 3 x 3 grid.

• Traditionally, the marks are X and O, and X goes first.

How might we represent a state?

• How many possible states are there?
• What about symmetry?
• Given a state, what moves are available?

photo by Przemysław Czopor

• Also called “knots and crosses” (English) or “exs and ohs” (Canada).
• Representation could be 3x3 array, list of 9 elements
  • Consider list of alternating moves labeled by an integer.
• Using simple boards, draw a sequence of moves with (directed) edges between them.
  • 3 possible values for each of 9 squares: \(3^9 = 19,683\)
  • But: There always has to be same number of X and O, or one more X.
  • Also: Rotational and mirror symmetries.
• Only 765 valid states after alternating play and symmetry.
  • 626 are mid game.
  • Remainder are terminal: 91 games X has won, 44 games O has won and 3 games are a draw.

TicTacToe State Space Graph

XKCD’s map of optimal moves

• Shows the entire state graph of the game (ignoring symmetries).
  • But the number of terminal states doesn’t line up with other sources…
• Early 1950s: One of the earliest video games (computer could play a perfect game).
• Late 1970s: MIT students built the tinker-toy mechanical computer.
• Let’s look at a more difficult game.

Sudoku

Sudoku

• Fill in the grid with the numbers 1 to 9.
  • No number may appear twice in a row, column, or 3x3 subgrid.

example starting board

[By Tim Stellmach - CC0, Link]

solution to example

[By en:User:Cburnett - CC BY-SA 3.0, Link]

Representing Sudoku

For an evolving system (typically Markovian):

• A state is the current status or configuration of the system.
• The state space is the set of all possible states.

How might you represent this Sudoku state?

• Remember: A system is Markovian if we need only its current state (nothing else about its history) to predict its future.
  • Is tic-tac-toe Markovian? Is sudoku?
• Could use
  • 2D array.
  • List of lists.
  • List of locations and values (very efficient if most locations are empty, much less so as the board fills up).
• Each entry could be integer, unsigned, interval, enumeration, string.
  • How do we represent an unfilled cell?

State Space Graphs

• A vertex is a (valid) state.
• Edges connect states if there is a valid move between them.

How many neighbors does this vertex have?

• Does sudoku have any invalid moves?
  • An invalid move results in an invalid state.
• In each board, enumerate the possible values in a different empty cell.
  • Do not enumerate in the (1,2) cell (we do that in the next slide).

Exploring the Sudoku Graph

• Given a vertex, we need to choose a neighbour vertex to consider.
  • Choose an empty cell, build set of possible consistent values, choose one.
  • Choose an empty cell, choose a value, see if next state is valid.

• “Choose” could mean a deterministic or random choice.
• We win if the valid state is full.
• We have to retreat if there are no valid neighbours.
• We will use the latter approach because it is easier to code: No need to reason about constraints, just pick a value and see if it is valid.

Graph Search

Reminder: Flood Fill Pattern

• enqueue a starting point
• while the queue is not empty:
  • v = dequeue
  • for each valid neighbor w of v:
    • process w
    • enqueue w

• Using a FIFO queue, we visited the pixels (nodes) in order of their distance (number of edges) from the initial pixel (node).

Breadth First Search (BFS)

• Explores a graph starting from a root node.
• Explores all nodes at a specified depth (distance from the root) before exploring any at the next depth.

Other animations of BFS

• see-algorithms.com
• algomaster.io

[By Blake Matheny, CC BY-SA 3.0]

• BFS worked great for flood fill / Voronoi regions.
• In Sudoku, it would fill in all possible values for a given empty cell before considering any other empty boxes.
• Why is it a bad idea for solving sudoku (or other games / mazes)?
  • You want to get to a terminal state.
  • Terminal state is a (relatively) long distance from the root.
  • There are a lot of intermediate states that BFS would have to consider before it could get to a terminal state.

Depth First Search (DFS)

• Explores a graph starting from a root node.
• Fully explores each subgraph before moving on to the next node at the current depth.

Other animations of DFS

• see-algorithms.com
• algomaster.io

[By Mre, CC BY-SA 3.0]

• For Sudoku, DFS keeps filling in new empty boxes until it hits an invalid state.

Implementing DFS

• Can be implemented via recursion.
• We will use a stack / LIFO queue.

Pseudo-code stack functions:

• Insert: push(item)
• Remove: pop() \(\rightarrow\) item

Python deque (or list) functions:

• Insert: append(item)
• Remove: pop() \(\rightarrow\) item

Depth First Search Practice

• push(start_vertex)
• while the stack is not empty:
  • v = pop()
  • if v is not processed:
    • process v
    • for each valid neighbor w of v:
      • push(w)

• Remember to start writing nodes from the bottom of the stack.

Back to Sudoku

Sudoku Solver Algorithm

• Search (DFS) through the states until you can’t go any farther.
  • If the board is complete, you win!
  • If the board is invalid, back up and try a new state in the most recent cell possible.

State Validity

Need to be able to check whether a state is valid.

Suppose we have a variable grid, representing the board, and we want to place a value called num, in position (x,y).

Need to check uniqueness in:

• row
• column
• block

• Which conditional checks a row?
• Which conditional checks a column?
• How shall we check a block?

Block Validity

Python tidbit: to query a region in a 2d matrix, define the bounds on the region and use in.

In the small example below, 2 in grid[0:2,0:2] returns True.

Defining Blocks

Given location \((x,y)\), determine the block in which it lives.

• a region s:t contains \(x\) if \(s\leq x< t\).
• Look for a pattern in the tables below for a \(4 \times 4\) grid.
• Can we generalize to an \(r^2 \times r^2\) grid?
  • Hint: x//r is the integer part of x/r.

• Generalization is [(x // r) * r : (x // r + 1) * r]

Which Cell Next?

We could choose next cell:

• Randomly. We would then either:
  • Have to keep explicit track of which cells were still empty.
  • Repeatedly choose full cells and have to choose again.
• Deterministically. We could either:
  • Build a double loop over 2D position \((x,y)\).
  • Build a single loop over 1D position and convert that to an \((x,y)\).

We will do the latter, mostly as an example of how to turn a multidimensional index into a one dimensional index (linearizing) and vice-versa.

Linearizing the Cell Index

Write a function postup that takes an integer position p as input, and returns an (x,y) position. The grid is size \(\times\) size.

x = p % size and y = p // size.

Demo

Today’s activity is already coded for you, but let’s look through the code.

Launch Class Activity: Sudoku in PrairieLearn.

Sudoku Closing Thoughts

How fast does the state space grow as board size grows?

size	cells	state space
2	4 x 4
3	9 x 9
4	16 x 16
5	25 x 25
\(r\)	\(r^2\) x \(r^2\)

Mathematics of Sudoku

Could we be smarter about what values to consider?

• There are \(r^4\) cells, each of which can have a value from 1 to \(r^2\). So it grows as \((r^2)^{(r^4)}\)!
• For classic (size 3) sudoku, there are roughly \(6.671×10^{21}\) states.
  • There are ways to reduce that by validity preserving transformations to just(!) 5,472,730,538.
  • Symmetry is an example of a validity preserving transformation, but it is not very useful in sudoku.
• That is exponential growth (the worst we considered). In fact, Sudoku is known to be NP-complete.