• Tree

  • theorem: when edge $e$ is added to a tree $T$, creates exactly 1 cycle
  • proof
    • there will be at least one cycle: as it has $n$ edges now
    • there can't be two cycle: as doing so would mean following situation
      • and, in this case, input contained cycle itself

graph TD
    1((1))
    2((2))
    3((3))
    4((4))
    1-->2
    2-->3
    1-->4
    1--e-->3
    4-->3

• a weighted graph $G=(V,E,w)$ consists of
  • $G=(V,E)$: a graph
  • $w:E\to \mathbb{R}$
• finding: shortest path
  • where distance of each edge: $w$
  • walk is more accurate, as it might not be a path
• previous theorem: every connected graph $G=(V,E)$ contains a subgraph
  • $T=(V,E_T)$ s.t. $T$ is a tree
  • such tree: spanning tree
• theorem: given a weighted graph $G$, a subtree $T\subseteq G$
  • is a minimum spanning tree (MST) if it is a spanning tree w/ least total weight
• algorithm to find MST: Kruskal's algorithm
  • sort: each weight in increasing order
  • for each (from minimum): take the edge if it doesn't create a cycle
  • 👨‍🏫 what is the cheapest edge to connect two connected components?
• there might be multiple MST!!
  • above algorithm: finds one such MST
  • 👨‍🏫 what is the maximum number of MST?
• algorithm works: as
  • it terminates as there are finite no. of edges
• output: connected graph given input is connected
• proof: suppose the output is not connected
  • i.e. there exists v</span>c=∅
  • and $c$: vertices in $T$
  • algorithm: went to all possible edges, should have checked c→v</span>c
• let $T$: output
  • and $T^{\ast }$ be MST
  • show: $w(T)\le w(T^{\ast })$
    • $w(T)$: sum of weights in graph (tree)
  • i.e. algorithm: chooses the same edge with $T^{\ast }$
    • and first edge to be not in $T^{\ast }$: $e$
  • consider: $T^{\ast }+e$
    • it is a cycle
    • however, the output is a tree
    • thus: $T^{\ast }$ must contain a path to connect vertices of $e$
      • let it be $e^{\prime }$
    • claim: $T^{\ast }+e-e^{\prime }$ is a tree
      • but the method of choosing $e$: edge w/ smallest possible weight
      • thus, $T^{\ast }+e-e^{\prime }$ must have a smaller weight than $T^{\ast }$
      • contradiction!
    • then: repeat until $T^{\ast }=T$
  • sometimes, algorithm: much simpler than proof of correctness!
• Prim's algorithm
  • picks a vertex $u$
  • then pick a cheapest edge from $u$
    • let it be to $v$
  • then, pick a cheapest edge from $v$, then repeat
    • condition: not making a cycle!
  • 👨‍🏫 what is the cheapest edge to connect an edge to my current cc?
• proof: similar to Kruskal's
  • 👨‍🏫 hint: assume ideal path, and compare & contrast
  • modify it until $T=T^{\ast }$

• Directed graph

  • directed graph: $G=(V,E)$
    • where $V$: set of vertices
    • and $e\in E$ of fork $(u,v)$
      • $\ne (v,u)$
    • 👨‍🏫 it's not a set, thus order matters
  • directed equivalent of connected component
    • candidate 1:
      • ignore the direction
      • consider it cc if its undirected case is a cc
      • 👨‍🏫 not very useful, as one cannot move one in cycle to another
  • vertices $u,v$: strongly connected (SC) iff
    • both $(u,v)$-path and $(v,u)$-path exists
  • strongly connected component (SCC): maximal subset of vertices
    • s.t. every two of them are SC
  • strongly connected graph: partitions your graph
    • every component: SC to itself
    • if $u$ SC to $v$ -> vice versa
    • $u\stackrel{SC}{\to }v$ and $v\stackrel{SC}{\to }t$ -> $u\stackrel{SC}{\to }t$
      • transitive
  • DAG: directed acyclic graph
    • example

graph TD
      1((1))
      2((2))
      3((3))
      1-->2
      2-->3
      3-->1

• $G$: has no cycle iff: every vertex of $G$: its own SCC
  • assume: $G$ has no cycles
    • let $u,v$: be two vertices
      • if $u,v$ in the same SCC: there must be both $(u,v)$ and $(v,u)$ path
    • then: connection of $(u,v)$ and $(v,u)$ path: closed walk
      • and all closed walk: implies existence of cycle
      • 👨‍🏫 proof: exactly same fore directed graph
      • contradiction, as $G$ is assumes to have no cycle
    • thus: every vertex of $G$: its own SCC
      • without extra members
  • assume: every vertex of $G$: its own SCC
    • let $C$: be a cycle
    • if $u,v\in C$: then both $(u,v)$ and $(v,u)$ path exist
      • thus, they must be in SCC
    • due to assumption: each cycle: contains at most 1 vertex
      • loop: meaningless

• Topological ordering

  • topological ordering: given directed graph $G=(V,E)$
    • permutation $\pi$ of vertices s.t. every edge $e\in E$: of the form
    • $(\pi (i),\pi (j))$
  • theorem: directed graph $G$: a DAG iff $G$ has a topological ordering
  • proof
    • $G$: w/ topological ordering: implies there is no cycle:
      • i.e. $G$ is a DAG
    • no cycle implies topological ordering
      • if there is no cycle: must exist a vertex w/ indegree 0
        • unless: has a cycle
      • assume: we create a left-to-right indegree
      • 👨‍🏫 similar to prerequisite problem, ain't it
    • d
  • for directed graph, both indegree and outdegree are defined
  • lemma: if a directed $G$, if outdegree of every vertex: at least 1
    • then there is a cycle
    • proof: keep going until you find a previously seen vertex
      • must end somewhere as the graph is finite
  • similar lemma: if a directed $G$, if indegree of every vertex: at least 1
    • then there is a cycle
    • proof: keep going backwards until you find a previously seen vertex
      • must end somewhere as the graph is finite

• DAG game

  • DAG game: a game w/ loopless DAG
    • two players w/ starting vertex $v_0$
      • w/ shared piece / position
    • each turn: player chooses an outgoing edge
    • player who can't make a move: loses
  • example board

graph LR
    1(( ))
    2(( ))
    3(( ))
    4(( ))
    5(( ))
    6(( ))
    7(( ))
    8(( ))
    9(( ))
    10(( ))
    11((L))
    1-->2
    2-->3
    1-->4
    4-->3
    1-->5
    5-->3
    3-->6
    3-->7
    7-->8
    8-->9
    8-->10
    9-->11
    10-->11

• play: a path on a DAG
• assume: both players are smart / doesn't make mistake
  • = optimal play
• properties
  • game: always ends
    • because: there is no cycle
      • and thus, there are at most $n-1$ (tree-like) steps
  • every vertex: either $W$ or $L$ (win / lose)
    • generally: if it has edge to $L$ vertex: it is a $W$
      • if it only has edge to $W$ vertex: it is a $L$
• successor: vertices that a vertex $v$ has (directed)

• Rooted trees

  • rooted tree: tree $T=(V,E)$, in which $r\in V$: chosen as root
  • s.t. it is ordered: from root to outwards
    • 👨‍🏫 sometimes it's the other way
  • tree: can be thought of a descendants, etc.
    • 👨‍🏫 interestingly, we often locate tree at the top
    • vertex without a successor / child: leaf
  • 👨‍🏫 definition of leaf: varies