DSCI 512 Lecture 3 : Graphs and Sparse Matrices

Sky (Kehan) Sheng

Housekeeping: labs

• “Single Attempt” on a lab question means one attempt per variant. You get unlimited attempts per question.

• New: the Jupyter scratchpad has starter code for every coding question. Play with the data and test your code there before you submit on PL.

• Week 1 practice problems are on PL. Keep practising as you study.

Housekeeping: live coding quizzes

• The goal is a safe space to make mistakes and practise before a real technical interview.
• Go to your own lab session. Bring your UBC ID, or show your photo on Canvas or Workday.
• Each quiz covers the previous week. This week: Week 1, binary and linear search.
• Grade by attempts: the first 5 attempts get full marks, the next 5 get 4, the next 5 get 3, then 2, then 1.
• Retakes: up to two extra tries, closed-book, new questions but on the same concepts. During any TA or instructor office hours, before November 6.

Last week’s quizzes were stressful for many of you, and that was not our intention. Everyone walked a different path to MDS with different prior exposure to coding, so we want to give you more room to practise.

Retake details:
Deadline: all retakes must be done before November 6.
Where: during any TA’s or instructor’s office hours.
Format: closed-book on PL (the lab quizzes are open-book). New questions that test the same concepts or algorithm as the quiz you are retaking.
Scheduling: if you cannot make office hours, contact the instructors and we will find another time.

We hope this takes some pressure off.

Where we stopped last time

The rest of lecture 2 shrinks Instagram’s user table about 10× by picking the right dtypes. Read it on your own: lecture 2 slides.

How does Instagram know who you might know?

You open Instagram. A card says Suggested for you: nori.

You have never met nori, but the card says Followed by clam, kelp and mochi.

Out of 3 billion users, how did Instagram pick nori? 🤔

• “mutual friends”?
• Follow up: what does Instagram need to store to answer that quickly?

Draw it

viewof suggest_step = Inputs.button([
  ["Back", i => Math.max(i - 1, 0)],
  ["Next step", i => Math.min(i + 1, suggest_steps.length - 1)],
  ["Start over", () => 0]
], {value: 0})

{
  // Print only: the sentence was written in Python (suggest_steps).
  const s = suggest_steps[suggest_step];
  return html`<div class="ojs-readout"><span class="sq-count">${s.count}</span> ${s.say}</div>`;
}

{
  // Draw only: every position, colour role and label was computed in Python.
  const s = suggest_steps[suggest_step];
  const base = friend_layout;
  const fill = {you: "#52514e", friend: "#2a78d6", pick: "#eb6834", other: "#b8b6b0"};
  const stroke = {friend: "#2a78d6", path: "#eb6834", base: "#d9d8d4"};
  const nodes = base.nodes.map((d, i) => ({...d, role: s.node_roles[i], label: s.labels[i]}));
  const edges = s.show_edges ? base.edges.map((d, i) => ({...d, role: s.edge_roles[i]})) : [];
  return Plot.plot({
    width: 900, height: 390, margin: 20,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: base.x_domain}, y: {axis: null, domain: base.y_domain},
    marks: [
      Plot.link(edges, {filter: d => d.role === "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: stroke.base, strokeWidth: 2}),
      Plot.link(edges, {filter: d => d.role !== "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: d => stroke[d.role], strokeWidth: 4}),
      Plot.dot(nodes, {x: "x", y: "y", r: 14, fill: d => fill[d.role], stroke: "white", strokeWidth: 2}),
      Plot.text(nodes, {x: "x", y: "y", text: "label", dy: -25, fontWeight: "bold"})
    ]
  });
}

Users and lines between them: this is called a graph.

• waffle and river never light up.

Graph, defined

A graph \(G = (V, E)\) has

• \(V\), a set of vertices (also called nodes): the users.
• \(E\), a set of edges: the friendships. Each edge \((u, v)\) connects two vertices \(u, v \in V\).

Many kinds of data are graphs:

data	vertices	edges
social network	people	who is friends with whom
the internet	web pages	which page links to which
transportation	cities	direct flights
MDS courses	courses	which course you need first

• A table is good when rows stand on their own. A graph is good when the connections are what we care about.
• Prerequisites: DSCI 511 before DSCI 512 is an edge.

Build it in networkx

One at a time: G.add_node("ada"), G.add_edge("sky", "otter"). Many at once: add_nodes_from, add_edges_from.

• nx.draw(G) draws it with matplotlib. Positions are random each run unless you pass pos=nx.spring_layout(G, seed=0): only nodes and edges matter, not where they are drawn.

Neighbours and degree

• \(u\) and \(v\) are neighbours if there is an edge between them.
• The degree of a vertex is the number of edges touching it.

viewof deg_who = Inputs.select(adj_view.users, {value: "sky", label: "user"})

{
  // Draw only: roles were computed in Python (user_views).
  const s = user_views[deg_who];
  const base = friend_layout;
  const fill = {you: "#52514e", friend: "#2a78d6", pick: "#eb6834", other: "#b8b6b0"};
  const nodes = base.nodes.map((d, i) => ({...d, role: s.node_roles[i]}));
  const edges = base.edges.map((d, i) => ({...d, role: s.edge_roles[i]}));
  return html`${Plot.plot({
    width: 600, height: 300, margin: 16,
    style: {fontSize: "15px", background: "transparent"},
    x: {axis: null, domain: base.x_domain}, y: {axis: null, domain: base.y_domain},
    marks: [
      Plot.link(edges, {filter: d => d.role === "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#d9d8d4", strokeWidth: 2}),
      Plot.link(edges, {filter: d => d.role !== "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#2a78d6", strokeWidth: 4}),
      Plot.dot(nodes, {x: "x", y: "y", r: 11, fill: d => fill[d.role], stroke: "white", strokeWidth: 2}),
      Plot.text(nodes, {x: "x", y: "y", text: "id", dy: -20, fontWeight: "bold"})
    ]
  })}<div class="ojs-readout">${s.degree_say}</div>`;
}

Paths and distance

viewof path_from = Inputs.select(adj_view.users, {value: "nori", label: "from"})

viewof path_to = Inputs.select(adj_view.users, {value: "ada", label: "to"})

{
  // Draw only: the shortest path was found in Python (path_lookup).
  const s = path_lookup[`${path_from}|${path_to}`];
  const base = friend_layout;
  const nodes = base.nodes.map((d, i) => ({...d, role: s.node_roles[i]}));
  const edges = base.edges.map((d, i) => ({...d, role: s.edge_roles[i]}));
  return html`<div class="ojs-readout">${s.say}</div>${Plot.plot({
    width: 820, height: 270, margin: 14,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: base.x_domain}, y: {axis: null, domain: base.y_domain},
    marks: [
      Plot.link(edges, {filter: d => d.role === "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#d9d8d4", strokeWidth: 2}),
      Plot.link(edges, {filter: d => d.role !== "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#eb6834", strokeWidth: 5}),
      Plot.dot(nodes, {x: "x", y: "y", r: 12, fill: d => d.role === "pick" ? "#eb6834" : "#b8b6b0",
                       stroke: "white", strokeWidth: 2}),
      Plot.text(nodes, {x: "x", y: "y", text: "id", dy: -22, fontWeight: "bold"})
    ]
  })}`;
}

• A path is a sequence of vertices joined by edges. Its length is the number of edges.
• The shortest one is the distance: “degrees of separation”.
• A cycle is a path that starts and ends at the same vertex: sky → clam → kelp → sky.

Shortest path in code

How does networkx find it? Breadth-first search, next lecture.

Connected or not?

{
  // Draw only: the components were found in Python (component_view).
  const s = component_view;
  const base = friend_layout;
  const color = {friend: "#2a78d6", pick: "#eb6834"};
  const nodes = base.nodes.map((d, i) => ({...d, role: s.node_roles[i]}));
  const edges = base.edges.map((d, i) => ({...d, role: s.edge_roles[i]}));
  return html`${Plot.plot({
    width: 820, height: 300, margin: 16,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: base.x_domain}, y: {axis: null, domain: base.y_domain},
    marks: [
      Plot.link(edges, {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: d => color[d.role], strokeWidth: 3}),
      Plot.dot(nodes, {x: "x", y: "y", r: 12, fill: d => color[d.role], stroke: "white", strokeWidth: 2}),
      Plot.text(nodes, {x: "x", y: "y", text: "id", dy: -22, fontWeight: "bold"})
    ]
  })}<div class="ojs-readout">${s.say}</div>`;
}

• Connected: there is a path between every pair of vertices.
• Our graph is disconnected: no path from sky to waffle. Instagram can’t suggest waffle through friends.
• Each separate group is a connected component.

Connected components in code

iClicker: how many edges?

A group chat of \(V\) users where everyone follows everyone. This is a complete graph: every pair of vertices has an edge.

How many edges does it have?

• (A) \(V - 1\)
• (B) \(V\)
• (C) \(\frac{V(V-1)}{2}\)
• (D) \(V^2\)

• Answer: C
• Each user has degree \(V - 1\). Adding up all \(V\) degrees counts every edge twice, once from each end.

Check it

viewof complete_n = Inputs.range([2, 10], {step: 1, value: 5, label: "number of users V"})

{
  // Draw only: positions, edges and the sentence were computed in Python (complete_views).
  const s = complete_views[complete_n];
  return html`<div class="ojs-readout">${s.say}</div>${Plot.plot({
    width: 420, height: 380, margin: 20,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: s.x_domain}, y: {axis: null, domain: s.y_domain},
    marks: [
      Plot.link(s.edges, {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: "#2a78d6", strokeWidth: 2}),
      Plot.dot(s.nodes, {x: "x", y: "y", r: 12, fill: "#2a78d6", stroke: "white", strokeWidth: 2}),
      Plot.text(s.nodes, {x: "lx", y: "ly", text: "id", fontWeight: "bold"})
    ]
  })}`;
}

About half of \(V^2\): a complete graph has \(O(V^2)\) edges. Keep this in mind for memory.

• nx.complete_graph(G.nodes) builds one in code.
• Real social networks are nowhere near complete. That is the whole point of sparse matrices later.

Graph types

Instagram followers are one-way

• Undirected: an edge goes both ways. Facebook friends: if Alice is friends with Bob, Bob is friends with Alice.
• Directed: an edge has a direction, drawn as an arrow. Instagram followers: You can follow natgeo without natgeo following you.

Degree splits in two:

• in-degree: arrows in, followers
• out-degree: arrows out, following

viewof follow_who = Inputs.radio(follow_view.users, {value: "natgeo", label: "user"})

{
  // Draw only: arrows and degrees were computed in Python (follow_view).
  const s = follow_view.lookup[follow_who];
  const color = {in: "#2a78d6", out: "#eb6834", base: "#c9c7c1"};
  const nodes = follow_view.nodes.map((d, i) => ({...d, role: s.node_roles[i]}));
  const arrows = follow_view.arrows.map((d, i) => ({...d, role: s.edge_roles[i]}));
  return html`${Plot.plot({
    width: 520, height: 330, margin: 16,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: follow_view.x_domain}, y: {axis: null, domain: follow_view.y_domain},
    marks: [
      Plot.arrow(arrows, {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: d => color[d.role],
                          strokeWidth: 3, insetStart: 16, insetEnd: 16, headLength: 12}),
      Plot.dot(nodes, {x: "x", y: "y", r: 13, fill: d => d.role === "you" ? "#52514e" : "#b8b6b0",
                       stroke: "white", strokeWidth: 2}),
      Plot.text(nodes, {x: "x", y: "y", text: "id", dy: -24, fontWeight: "bold"})
    ]
  })}<div class="ojs-readout">${follow_who}: <span class="notify">${s.in_say}</span>,
    <span class="match">${s.out_say}</span></div>`;
}

• Directed graphs can also have self-loops, an edge from a node to itself. You’ll meet them in Markov chains (DSCI 575).

Directed graphs in code

Weighted graphs

Weighted: every edge carries a number. Unweighted: an edge either exists or it doesn’t.

{
  // Draw only: widths and label positions were computed in Python (weighted.dm).
  const w = weighted.dm;
  return Plot.plot({
    width: 460, height: 300, margin: 10,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: w.x_domain}, y: {axis: null, domain: w.y_domain},
    marks: [
      Plot.link(w.lines, {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: "#2a78d6", strokeWidth: "width"}),
      Plot.text(w.lines, {x: "lx", y: "ly", text: "weight", fontWeight: "bold",
                          stroke: "white", strokeWidth: 5, fill: "#0b0b0b"}),
      Plot.dot(w.nodes, {x: "x", y: "y", r: 13, fill: "#b8b6b0", stroke: "white", strokeWidth: 2}),
      Plot.text(w.nodes, {x: "x", y: "y", text: "id", dy: -24, fontWeight: "bold"})
    ]
  });
}

Undirected: one number per pair. Weight = number of mutual friends, 12 mutual friends between sky and otter.

{
  // Draw only: widths and label positions were computed in Python (weighted.likes).
  const w = weighted.likes;
  return Plot.plot({
    width: 460, height: 300, margin: 10,
    style: {fontSize: "16px", background: "transparent"},
    x: {axis: null, domain: w.x_domain}, y: {axis: null, domain: w.y_domain},
    marks: [
      Plot.arrow(w.lines, {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: "#eb6834",
                           strokeWidth: "width", insetStart: 16, insetEnd: 18, headLength: 5}),
      Plot.text(w.lines, {x: "lx", y: "ly", text: "weight", fontWeight: "bold",
                          stroke: "white", strokeWidth: 5, fill: "#0b0b0b"}),
      Plot.dot(w.nodes, {x: "x", y: "y", r: 13, fill: "#b8b6b0", stroke: "white", strokeWidth: 2}),
      Plot.text(w.nodes, {x: "x", y: "y", text: "id", dy: -24, fontWeight: "bold"})
    ]
  });
}

Directed: one number per direction. Weight = likes given: sky liked otter 40 times, otter liked sky only 3 times.

Weighted graphs in code

Question: which kind of graph?

A soccer league: two teams are connected if they played each other, labelled with how many games they played.

• (A) undirected, unweighted
• (B) undirected, weighted
• (C) directed, unweighted
• (D) directed, weighted

• Answer: B. A game involves both teams, so there is no direction, and the number of games is the weight.

How do we store a graph?

Two standard ways: an adjacency list and an adjacency matrix. The list is a dict, so first a short detour.

A plain dict and a missing key

Who liked your posts today? Count the likes per user.

likes = ["otter", "clam", "otter", "kelp", "otter"]

counts = {}
for user in likes:
    counts[user] += 1     # "otter" is not a key yet

You have to check every key yourself:

defaultdict does the check for you

defaultdict(f) calls f() to make the value for a key it has not seen yet.

int to count, list to group, set to collect unique items.

• Still a hash table underneath: same O(1) lookups as dict.

Two things to watch

⚠️ Just looking at a missing key adds it:

Why defaultdict(list) and not defaultdict(list())?

• defaultdict needs a function it can call for every missing key. list is that function.
• list() is one empty list that already exists. It raises a TypeError.

• Same reason it is defaultdict(int), not defaultdict(0).
• Plain dict: you control every key that gets created. defaultdict can hide a typo by quietly adding a key.

Counter is made for counting

How many r’s are in “strawberry”? One line.

you want to…	use
look things up, every key known up front	dict
group items under a key	defaultdict(list) or defaultdict(set)
count things	Counter or defaultdict(int)

• Strawberry: early chatbots famously got this wrong. A string is a sequence of letters, so Counter counts letters.

Adjacency list

For every user, keep a list of their friends: a dict of lists.

Directed graph? Drop the second append: an edge from u to v only goes in u’s list.

• This is how the picture on the next slides is built, same order of neighbours.

Adjacency list with networkx

Edge lists often come as a table. nx.from_pandas_edgelist turns one into a graph:

iClicker: space of an adjacency list

What is the space complexity of an adjacency list, with \(V\) vertices and \(E\) edges?

• (A) \(O(V)\)
• (B) \(O(E)\)
• (C) \(O(VE)\)
• (D) \(O(V + E)\)

• Answer: D
• One key per vertex: \(O(V)\). Each edge appears once, or twice if undirected: \(O(E)\).
• Not \(O(E)\): a graph can have vertices and no edges. Not \(O(V^2)\): most graphs are far from complete.

• \(2E\) is still \(O(E)\).
• If the graph is complete, E is about V²/2 and O(V + E) becomes O(V²). The formula still holds, E is just big.

Adjacency matrix

Number the vertices \(1, \dots, V\). The adjacency matrix \(A\) is \(V \times V\):

\[a_{ij} = \begin{cases} 1, & \text{if there is an edge from } i \text{ to } j \\ 0, & \text{otherwise} \end{cases}\]

• \(a_{ij}\) is the entry in row \(i\), column \(j\).
• Lecture 2: one number per pair of users. Here it is.

Same graph, two ways

viewof adj_who = Inputs.select(adj_view.users, {value: "clam", label: "user"})

{
  // Draw only: the graph roles, the list lines and the matrix rows were computed in Python.
  const s = user_views[adj_who];
  const base = friend_layout;
  const fill = {you: "#52514e", friend: "#2a78d6", other: "#b8b6b0"};
  const nodes = base.nodes.map((d, i) => ({...d, role: s.node_roles[i]}));
  const edges = base.edges.map((d, i) => ({...d, role: s.edge_roles[i]}));
  const graph = Plot.plot({
    width: 290, height: 240, margin: 12,
    style: {fontSize: "13px", background: "transparent"},
    x: {axis: null, domain: base.x_domain}, y: {axis: null, domain: base.y_domain},
    marks: [
      Plot.link(edges, {filter: d => d.role === "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#d9d8d4", strokeWidth: 1.5}),
      Plot.link(edges, {filter: d => d.role !== "base", x1: "x1", y1: "y1", x2: "x2", y2: "y2",
                        stroke: "#2a78d6", strokeWidth: 3}),
      Plot.dot(nodes, {x: "x", y: "y", r: 7, fill: d => fill[d.role], stroke: "white", strokeWidth: 1.5}),
      Plot.text(nodes, {x: "x", y: "y", text: "id", dy: -14, fontWeight: "bold"})
    ]
  });
  const list = adj_view.lines.map((line, i) => html`<div class="${s.list_cls[i]}">${line}</div>`);
  const header = html`<tr><th></th>${adj_view.short.map(h => html`<th>${h}</th>`)}</tr>`;
  const rows = adj_view.rows.map((row, i) => html`<tr class="${s.row_cls[i]}">
      <th>${adj_view.short[i]}</th>${row.map(v => html`<td class="${v ? "one" : ""}">${v}</td>`)}</tr>`);
  return html`<div class="adj-wrap">
      <div class="adj-panel">${graph}<div class="ds-caption">graph</div></div>
      <div class="adj-panel"><div class="adj-list">${list}</div><div class="ds-caption">adjacency list</div></div>
      <div class="adj-panel"><table class="adj-table">${header}${rows}</table><div class="ds-caption">adjacency matrix</div></div>
    </div>
    <div class="ojs-readout">${s.matrix_say}</div>`;
}

• Same information three times. The list stores only the friends, the matrix stores a 0 for every non-friend too.
• The matrix is symmetric because the graph is undirected: row clam, column sky and row sky, column clam are both 1.
• Pick waffle: one 1 in a row of 11. Most of the matrix is zeros.

Reading the matrix

• Row sum = degree.
• Undirected, so \(a_{ij} = a_{ji}\): symmetric. A directed graph’s matrix usually isn’t.
• Is there an edge? One lookup, A[i, j]: \(O(1)\).

Question: space of an adjacency matrix

• (A) \(O(VE)\)
• (B) \(O(E^2)\)
• (C) \(O(V^2)\)
• (D) \(O(V + E)\)

• Answer: C. One number per pair of vertices, edge or not.

• Think, pair, share: not an iClicker question. Give them a minute with a neighbour first.

Directed: read it off the matrix

The follow graph from earlier, as a matrix:

row follows column	sky	otter	clam	kelp	natgeo
sky	0	1	0	0	1
otter	1	0	0	0	1
clam	0	0	0	0	1
kelp	1	0	0	0	0
natgeo	0	0	0	0	0

• Who follows whom? Draw it on paper.
• Is it symmetric? No: sky → natgeo is a 1, natgeo → sky is a 0.
• Only sky and otter have a 1 both ways: they follow each other.

• Add up a column to get followers (in-degree): natgeo has 3.
• Board: sketch the arrows from the rows, then compare with the follow slide.

Which one to use?

	adjacency list	adjacency matrix
space	\(O(V + E)\)	\(O(V^2)\)
is there an edge from \(u\) to \(v\)?	\(O(\text{degree of } u)\), \(O(V)\) worst case	\(O(1)\): A[u, v]
all neighbours of \(u\)	\(O(\text{degree of } u)\)	\(O(V)\): scan the row
good for	big graphs with few edges	small or dense graphs

A trick from lecture 2: store neighbours in a set, and the edge check is \(O(1)\) on average. networkx does this: a graph is a dict of dicts.

• Walking the graph = BFS and DFS, next lecture.
• G.has_edge(u, v) is fast because of the dict of dicts.

Can we have both?

• A sparse matrix gets close to both. networkx already uses one:

Sparse matrices

Store only the friendships, not the 3 billion “no”s.

“Sparse matrix” means two things

• In maths: a matrix that is mostly zeros.
• In code: a data structure that stores only the non-zero entries.
• Use the data structure when your matrix is mostly zeros.

Our friend graph, stored sparse

• 26 stored values, not 13: each friendship sits in two places, [u, v] and [v, u].
• ⚠️ .toarray() is fine for 11 users. On a big matrix it is how you crash your kernel.

How much memory does it save?

A random graph with 100,000 users, where each possible friendship exists with probability 0.0001:

G_big = nx.fast_gnp_random_graph(100_000, 1e-4, seed=512)
am_big = nx.adjacency_matrix(G_big)

V = G_big.number_of_nodes()
E = G_big.number_of_edges()
print(f"V = {V:,} users, E = {E:,} friendships, nnz = {am_big.nnz:,}")

dense_bytes = V**2 * 8                                                    # every entry, 8 bytes each
sparse_bytes = am_big.data.nbytes + am_big.indices.nbytes + am_big.indptr.nbytes   # only what is stored
print(f"dense:  {dense_bytes / 1e9:,.1f} GB")
print(f"sparse: {sparse_bytes / 1e6:,.1f} MB")

V = 100,000 users, E = 499,519 friendships, nnz = 999,038
dense:  80.0 GB
sparse: 16.8 MB

• nnz is twice E: every friendship is stored at [u, v] and [v, u].
• The three arrays (data, indices, indptr) are unpacked in a few slides.
• 80 GB won’t fit on a laptop. A few MB is nothing.

The formula

At 8 bytes per number, for an undirected graph:

	what is stored	bytes	space
dense matrix	all \(V^2\) entries	\(8V^2\)	\(O(V^2)\)
sparse matrix (CSR)	data + indices + indptr	\(8 \times (\text{nnz} + \text{nnz} + V + 1)\)	\(O(V + E)\)

with \(\text{nnz} = 2E\).

Same space complexity as an adjacency list, and that is no coincidence.

• Lecture 2 dtype tricks work here too: an unweighted graph only needs bool values (1 byte), and int32 indices (4 bytes) are enough below about 2 billion users.

The three arrays of CSR

CSR = Compressed Sparse Row. Walk the matrix row by row and keep only the non-zeros, in three arrays.

• data: the non-zero values, row 0 first. nnz of them.
• indices: the column of each value in data. nnz of them.
• indptr: how many non-zeros come before each row, which is also where the row starts in data. \(V + 1\) of them.

indptr starts at 0, ends at nnz, and row \(i\) is data[indptr[i]:indptr[i+1]].

• Build indptr by counting the non-zeros in each row, then keep a running total that starts at 0.
• Next slide: our 3 by 3 example has 4 non-zeros, so data and indices have 4 entries and indptr has 4.
• Tiny check on the board first: rows with 1, 0, 2, 1 non-zeros give indptr = 0, 1, 1, 3, 4.

How CSR stores a matrix

Click through the rows and watch the three arrays fill in.

viewof csr_row = Inputs.radio(csr_view.rows, {value: -1, label: "fill in", format: i => i < 0 ? "start" : `row ${i}`})

{
  // Draw only: the arrays and the highlights were computed in Python (csr_view).
  const s = csr_view.steps[csr_row];
  const header = html`<tr><th></th>${csr_view.col_labels.map(h => html`<th>${h}</th>`)}</tr>`;
  const rows = s.rows.map((r, i) => html`<tr class="${r.cls}"><th>row ${i}</th>
      ${r.cells.map(c => html`<td class="${c.cls}">${c.v}</td>`)}</tr>`);
  const nnzRows = s.nnz.map(r => html`<tr class="${r.cls}"><td>${r.v}</td></tr>`);
  const boxes = items => items.map(b =>
    html`<div class="ds-box ${b.cls}">${b.label}<span class="sq-tag below">${b.tag}</span></div>`);
  return html`<div class="adj-wrap csr-wrap">
      <div class="adj-panel"><table class="adj-table">${header}${rows}</table>
        <div class="ds-caption">the matrix</div></div>
      <div class="adj-panel"><table class="adj-table">
          <tr><th>non-zeros</th></tr>${nnzRows}</table>
        <div class="ds-caption">count per row</div></div>
      <div class="adj-panel">
        <div class="ds-row csr"><span class="csr-name">data</span>${boxes(s.data)}</div>
        <div class="ds-row csr"><span class="csr-name">indices</span>${boxes(s.indices)}</div>
        <div class="ds-row csr"><span class="csr-name">indptr</span>${boxes(s.indptr)}</div>
        <div class="ds-caption">what CSR stores (small numbers: position in the array)</div></div>
    </div>
    <div class="ojs-readout">${s.say.join(" ")}</div>`;
}

• data: the non-zero values, row by row. indices: the column of each one. indptr: how many non-zeros come before each row.
• The non-zeros column is only a helper to count. CSR does not store it.
• Row 1 is empty: indptr[1] and indptr[2] are both 2.
• indptr has one more entry than rows, so the last row knows where it ends.
• Each row’s slice is that vertex’s list of neighbours: CSR is an adjacency list packed into flat arrays.
• Diagram in the lecture notes, section 4.3.

Today’s cheat sheet

Storing a graph with \(V\) vertices and \(E\) edges:

representation	space	edge from \(u\) to \(v\)?	neighbours of \(u\)	use it when
adjacency list (dict of lists)	\(O(V + E)\)	\(O(\text{degree of } u)\)	\(O(\text{degree of } u)\)	the graph is big, has few edges, or changes often
adjacency matrix (NumPy)	\(O(V^2)\)	\(O(1)\)	\(O(V)\)	the graph is small, or most pairs are connected
sparse matrix (CSR)	\(O(V + E)\)	\(O(\text{degree of } u)\)	\(O(\text{degree of } u)\)	the graph is big and you want matrix maths

Today’s takeaways

• A graph is vertices plus edges. Directed or not, weighted or not.
• networkx: G.neighbors(v), G.degree(v), nx.shortest_path_length(G, u, v), nx.connected_components(G).
• defaultdict fills in missing keys, Counter counts a whole list in one step.
• Adjacency list: \(O(V + E)\). Adjacency matrix: \(O(V^2)\). Real graphs have far fewer than \(V^2\) edges.
• A sparse matrix stores only the non-zeros. CSR is fast at rows, CSC at columns. Never .toarray() a big one.

Questions?