We remarked on proofs of correctness using Loop Invariant was a harbinger of the general algorithm for minimum weight spanning tree (MWST) to be discussed later in the week.
Other introductory remarks reflected the importance of the asymptotic growth rate measure of worst-case complexity (classes BigOh, LittleOh, Omegas and Thetas) as functions of input size, or some input parameter. As an example, we discussed a simple combinatorial graph G=(V,E,w), where edges E are weighted with integers w not greater than M.
Different data structures can be used to represent graphs. The most common is adjacency matrix, which is a square array indexed by vertices (vertices are usually denoted 1..n); the (i,j)-th entry of an adjacency matrix A is either 1 (encoding the edge (i,j), meaning that the vertices i and j are adjacent) or 0 (when the vertices are not adjacent.) In the undirected case the matrix is symmetric, A[i,j]=A[j,i]; this is not necessarily true in the case of a directed graph. When the graph is weighted, the non-zero entries of the adjacency matrix usually contain the edge weights.
While the adjacency matrix is a convenient representation of a graph, allowing, for instance, a constant time checking whether two vertices are adjacent, it uses \Theta(n^2) space, even when there are only o(n^2) pairs of adjacent vertices (in this case we say that the matrix -- or the graph -- is sparse.) If we are concerned with memory usage, we may use one of data structures discussed in conjunction with sparse table representations. For instance, we can use adjacency lists: for each vertex, the list of adjacent vertices is available (and if the graph is weighted, the weight for each edge; one can view it as list encoding of adjacency matrix rows.) While we often describe complexity of algorithms on such graphs as a function of n (the number of vertices), the input size is better described as proportional to (n choose 2)log(M).
We concluded the hour with contrasting the concrete complexity considerations (efficient algorithms) with that of abstract complexity which discusses problems for which no polynomial time algorithms seem to exist (the problem P=NP?)