---

Solution: Since G is connected, then for any two nodes in G, there is a path between these two nodes in G. Pick any node s in G. Consider the tree constructed during Breadth First Search (BFS) starting at s. Now take a node x in the last level of this BFS tree. We claim the graph resulting from eliminating x from G (let's call it G-{x}) is still connected.

Let's prove our claim: Let u and v be two nodes in G-{x}. One of the following two cases holds:

• u and v appear on the same branch of the BFS tree of G. Since x was removed from the very end of a branch, then its removal cannot break the path between u and v on this tree.
• u and v appear on different branches of the BFS tree of G. Then the concatenation of the path between u and s and the path between s and v provides a path between u and v on this tree.

It is easy to see that the removal of x from G doesn't break any of the paths on the BFS tree (since x is a leaf in that tree). Hence, all the paths in the BFS tree are preserved in G-{x}, and so in any of the two cases above, u and v remain connected in G-{x}.

---

---

Solution:
Strongly connected graph G (graph on the left) and G - {z} (graph on the right)

Note that G is strongly connected. That is, there for each two nodes u and v in the graph, there is a path between u and v, and a path between v and u. However, removing any node (and its incident edges) results in a graph in which there is a path from one of the remaining nodes to the other, but not vice versa. This is illustrated in the figure above for G - {z}.

---

1. (5 Points) Write detailed pseudo-code for an algorithm that receives a graph G=(V,E) as input, and produces G^C = (V,E^C) as output. Assume that both G and G^C are represented using an adjacency matrix representation. The more efficient your algorithm, the better. Explain your work.

   ---

   Let n be the number of nodes in G. Solution:

   For i := 1 to n {
      For j:= 1 to n {
         If adjacency_matrix[i,j] == 0
         then adjacency_matrix[i,j] := 1
         else adjacency_matrix[i,j] := 0
      }
   }
   

   Actually, one could simplify the pseudo-code above to:

   For i := 1 to n {
      For j:= 1 to n {
         adjacency_matrix[i,j] := 1 - adjacency_matrix[i,j] 
      }
   }
   

   ---

2. (10 Points) Analyze the time complexity of your algorithm above instruction by instruction. Produce a function T(n,m) that measures the runtime of your algorithm for an input graph with n nodes and m edges. Provide a tight asymptotic bound f(n,m) for T(n,m). That is, provide a function f(n,m) and prove that T(n,m) is Θ(f(n,m)).

   ---

   Solution:

   		Time per instruction	Number of iterations	Total
   1.	For i := 1 to n {	c1	n	c1*n
   2.	For j := 1 to n {	c2	n2	c2*n2
   3.	adjacency_matrix[i,j] := 1 - adjacency_matrix[i,j]	c3	n2	c3*n2
   	TOTAL			c1*n + c2*n2 + c3*n2 = Θ(n2)

   Note that c₁*n + c₂*n² + c₃*n² = Θ(n²) since for all n ≥ 1, n² ≤ c₁*n + c₂*n² + c₃*n² ≤ (c₁+c₂+c₃)*n².

   In summary, given that all the algorithm does is to access each of the n² cells of the adjacency matrix exactly once, the runtime of the algorithm is Θ(n²): It will have to perform at least and at most n² operations (i.e., it is Ω(n²) and O(n²) respectively).

   ---

1. (15 Points) Write another detailed pseudo-code for an algorithm that receives a graph G=(V,E) as input, and produces G^C = (V,E^C) as output. Assume that both G and G^C are represented using an adjacency list representation. (Do NOT assume that the neighbors of a node are organized in any particular order in the node's adjacency list). The more efficient your algorithm, the better. Explain your work.

   ---

   Solution: Let n be the number of nodes in G. The following algorithm to construct the adjacency list representation of G^C based on that of G might not be the most efficient, but it is very easy to understand.

   
   Let's use an auxiliary array neighbor of size n to record which nodes 
   are adjacent to the node under consideration in graph G.
   
   For i := 1 to n {
   
      /* initialize array neighbor: */
   
      For j:= 1 to n {
          neighbor[j] := 0 
      }
   
      /* traverse the adjacency list for node i in graph G */ 
      /* and record i's neighbors in array neighbor:       */
   
      For each edge (i,j) incident to i in G {
          neighbor[j] := 1 
      }
   
      /* create the adjacency list for node i in graph GC: */ 
   
      For j:= 1 to n {
         If neighbor[j] == 0
         then add the edge (i,j) to the adjacency list of i in GC
      }
      
   }
   
   

2. (15 Points) Analyze the time complexity of your algorithm above instruction by instruction. Produce a function T(n,m) that measures the runtime of your algorithm for an input graph with n nodes and m edges. Provide an upper asymptotic bound g(n,m) for T(n,m). That is, provide a function g(n,m) and prove that T(n,m) is O(g(n,m)).

   ---

   Solution:

   		Time per instruction	Number of iterations	Total
   1.	For i := 1 to n {	c1	n	c1*n
   2.	For j:= 1 to n {	c2	n2	c2*n2
   3.	neighbor[j] := 0 }	c3	n2	c3*n2
   4.	For each edge (i,j) incident to i in G {	c4	&Sigmani=1 degree(i) = 2m	c4*2m
   5.	neighbor[j] := 1 }	c5	&Sigmani=1 degree(i) = 2m	c5*2m
   6.	For j:= 1 to n {	c6	n2	c6*n2
   7.	If neighbor[j] == 0	c7	n2	c7*n2
   8.	then add the edge (i,j) to the adjacency list of i in GC }	c8	&Sigmani=1 (n-degree(i)) = n2 - 2m	c8*n2 - c8*2m
   	TOTAL			c1*n + (c2+c3+c6+c7+c8)*n2 + (c4+c5-c8)*2m = O(n2 + m) = O(n2)

   Note that since m = O(n²), then O(n² + m) = O(n²).

   ---