Programming, problem solving, and algorithms

CPSC 203, 2026 W1

October 22, 2026

Announcements

• Practice examlet 3 available.
• Book your slot for examlet 3.
• Lab 6 (stacks) and POTW 6 (summations and stacks) due Sunday.
• Project 1 due Monday (~96 hours!).

Voronoi Diagrams (continued)

Algorithmic Art Reminder

1. Select a subset of points from the original image as centers
2. Build the Voronoi diagram for those centers.
3. To visualize the Voronoi regions, fill each region in a new image with the same colour as the center of that region.

For visualization purposes, centers are shown in red. Generating those red squares was the effect of the dead code in the previous lecture’s class activity.

Aside: Some Technical Bits in the Loop-Based Solution

Look back in last lecture’s Class Activity: Voronoi Art at voronoi_loop_answer_nb.py.

• What does the code protected by extra_code do?

• Pillow library’s Image.load() method and the PixelAccess class

• That code produces little red squares in the image on top of the chosen centers.
• With a PixelAccess object you can index into the image data like a 2D array. The actual way in which the data is stored is hidden inside the dunder methods, so you don’t care what it might be.

Analysis (Loop-based Version)

How much work is done?

1. Read image:
2. Choose centers:
3. Build new image:
   
   
   
   
   
4. Write out new image:

Size of the image: \(n\)
(\(n =\) width \(\times\) height)

Density of centers: \(d\)

Number of centers: \(dn\)

1. \(O(n)\).
2. Hopefully \(O(dn)\).
3. \(O(dn^2)\).
4. \(O(n)\).

Can we do better? Do we need to “visit” (do something for) every pixel? Yes: At a minimum we need to write out a colour for that pixel. So, we probably can’t avoid \(O(n)\). But what about the dependence on number of centers? Can we avoid doing something for each pixel-center combination?

Can we do better?

• Starting at each center, fill in the immediate neighbours.
• Then fill in the neighbours of the neighbours.
• Repeat until all pixels are filled.
• Each pixel is visited just once.
• But how do we know which pixel to fill next?
  • We want to fill all the 1-neighbours, then all the 2-neighbours, etc.
  • We know that the 1-neighbours are the neighbours of the centers.
  • We know that the 2-neighbours are the neighbours of the 1-neighbours.
  • Can we arrange to see the centers first, then their neighbours, then their neighbours, …?

Data Structure: Queue

To implement the fill we use a datastructure called a queue.

Operations on a queue:

• enqueue(d): places data d at the “end” / “bottom” of the queue.
• dequeue(): removes and returns the element at the “start” / “top” of the queue.

How does the queue differ from the stack you were exploring in the lab? These two structures are also sometimes called FIFO (queue) or LIFO (stack).

A queue is a generic name for a data structure with this behaviour, and enqueue and dequeue are generic names for the operations that you perform on this data structure.

You will actually implement a queue in Python using the deque data structure from the collections module, and the methods for enqueue and dequeue will have different names.

Pattern: Flood Fill

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

• Put 63 at the right end of the queue.
• What makes a “neighbour”?
• What makes a “valid” neighbour?
• What does it mean to “process” a pixel?

Queue for Voronoi Art

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

• Put 63 and 21 at the right end of the queue.
• Stop to discuss pseudocode vs code. Note that AI chatbots understand pseudocode.

Designing a Solution

We’ll use collections.deque as our queue.

1. What should we put on the queue?
2. What deque methods will we use?
3. How can we check if a deque is empty?
4. What are the “neighbors” of pixel (x,y)?
5. What would be an invalid neighbor?

Aside: Queues are also available from Python’s queue library.

1. Centers to start, then neighbour pixels. What do we need to know about the thing put on the queue? Its location, maybe colour.
2. append and popleft. Alternatively, could use appendleft and pop. Pick a direction and stick with it!
3. Could check len(queue) == 0. Or could use while queue: loop (remember that Python always has a boolean interpretation of any piece of data).
4. (x-1,y), (x,y-1), (x+1,y), (x,y+1).
5. Pixel outside an image or pixel that has already been processed.

Queue library features: - Safe for parallel algorithms and in some cases more powerful (such as queue.PriorityQueue). - Slower and take up more memory.

Demo

Open today’s activity. We’ll implement the queue-based version of the algorithm.

• Launch Class Activity: Voronoi Art Fast in PrairieLearn.
• Open voronoi_deque_nb.py.

Aside: Measuring Distance and the Choice of Neighbours

How far away are the diagonal pixels?

regular distance

four neighbours

eight neighbours

Why didn’t we need to use our distance computation method in the queue-based version?

Easy to swap four and eight neighbours in our queue-based code. Regular distance can be implemented with a priority queue (and you will need to actually compute the regular distance).

If time, write 2-norm, 1-norm and ∞-norm distances.

Analysis (Queue-based Version)

How much work is done?

1. Read image: \(O(n)\)
2. Choose centers: \(O(dn)\)
3. Build new image:
   
   
   
   
   
4. Write out new image: \(O(n)\)

Size of the image: \(n\)
(\(n =\) width \(\times\) height)

Density of centers: \(d\)

Number of centers: \(dn\)

Show \(O(n)\): Consider a single pixel

• When it is noticed as a neighbour (by a constant number of possible neighbours):
  • Determine if it is valid: constant.
  • Assign a center: constant.
  • Assign a colour: constant.
  • Enqueue: constant.
• Wait on queue: Unknown, but accounted by pixels ahead of it in the queue.
• When it is dequeued:
  • dequeue: constant.
  • determine neighbours: constant.
• Pixel is never worked on again.

Each pixel has a constant amount of work associated with it, so \(O(n)\).