Algorithms Q&A - Recent questions and answers in Graph Theory

Answered: Graph with no 3-clique that needs at least 4 colors

Sat, 16 Dec 2023 23:11:15 +0000

Below graph does not contain any triangle and it is 4 colorable as shown. This graph is known, it is called "Grötzsch Graph".

Some sources for more information about the graph:

Answered: Give an example of a graph that has 6 vertices, 9 edges, but does not have a clique on 3 vertices

Tue, 12 Dec 2023 23:17:02 +0000

/Users/yingliu/Downloads/IMG_61E92A670424-1.jpeg

Here is my answer.

Answered: Give an example of a graph without an articulation point, a Hamiltonian cycle, or a 2-coloring

Wed, 06 Dec 2023 23:29:07 +0000

 A-----------B 
|       |
 |             /  |  \
 |           /    |    \
 |         E    |      F 
 |          \     |     /
 |            \   |   /
|       |
 D----------C

In this graph:

It does not have an articulation point, as removing any single vertex does not disconnect the graph.
It has no Hamiltonian cycle, as no cycle visits each vertex exactly once.
It does not have a valid 2-coloring, it requires at least 3 colors( Red, Green, Blue) to avoid adjacent vertices having the same color- Represented in colored format in the graph.

Answered: Example of a graph that is connected, has articulation point, needs 4 colors, and does not have a 4-clique

Mon, 20 Nov 2023 01:32:44 +0000

The following graph satisfies all the four conditions:

The connected graph has an articulation point "3". Vertex coloring "4" as shown in image and has maximum clique of "3".

Answered: Polynomial time solution for Constrained Version of Tetris Problem

Tue, 30 Apr 2019 23:13:01 +0000

The easiest way I think of is the exhaustive method. Do it with a matrix. It should be polynomial time. I cannot find a method to quickly make sure it is optimal without exhaustive method because the result seems to change time by time. I am not sure but constrained version seems do not change the time complicity? It only adds 4 possibilities.

Answered: How to generate a random connected graph?

Tue, 14 Nov 2017 16:46:03 +0000

To start, you can generate a random, connected tree by doing a random walk, except each step of the walk actually creates a the edge. This approach runs in O(V).

Code in Python

#PRE: V for the number of vertices
#POST: creates a random connected graph with a V-1 edges
def generateRandomConnectedGraph(self, V):
initialSet = set()
  visitedSet = set()
  vertices = set()
  edges = set()
  #generate the set of names for the vertices
  for i in range(V):
      initialSet.add(str(i))
      vertices.add(str(i))
  #set the intial vertex to be connected
  curVertex = random.sample(initialSet, 1).pop()
  initialSet.remove(curVertex)
  visitedSet.add(curVertex)
  #loop through all the vertices, connecting them randomly
  while initialSet:
      adjVertex = random.sample(initialSet, 1).pop()
      edge = (random.randint(WEIGHT_MIN,WEIGHT_MAX), curVertex, adjVertex)
      edges.add(edge)
      initialSet.remove(adjVertex)
      visitedSet.add(adjVertex)
      curVertex = adjVertex
  return vertices, edges

From there, you can add random edges to the graph. I have not found a great approach to this, so the current method I use is generate all possible edges that can be created (ignoring the weights) between any two nodes and then randomly choose from that list. That generation of combinations takes O(V²) time.

Code in Python:

#PRE: the number of elements in a list
#POST: generate a 2D array of all combinations
def generateCombination(n):
com = []
  for i in range(n):
      for j in range(i+1, n):
          com.append([i,j])
          com.append([j,i])
  return com

In total, this whole process takes O(V) + O(V²) + O(E-A) where A is the number of edges left to generate after creating the initial tree. So a O(V²). Not great but currently good enough for my purposes.

Answered: Heap removing and adding

Mon, 10 Oct 2016 23:52:39 +0000

I guess that this is correct because this is the standard heapify() operation.

The heapify() operation only assumes that both child trees are heap. Removing the top node does not break that very only assumption of the heapify() method. The pseudo-code for the method is shown below:

procedure heapify(H)

     if H.LeftChild > H.RightChild then

         if H.LeftChild>H.Root then

               swap(H.Root,H.LeftChild);

               heapify(H.LeftChild);

        endif

   elsif H.LeftChild <= H.RightChild then

         if H.RightChild>H.Root then

               swap(H.Root,H.RightChild);

               heapify(H.RightChild);

        endif

   endif

endprocedure

This function use recursive calls to extract the solution.

Answered: Graph Example n >= 6, delta >= 4, ki = 2

Thu, 01 Sep 2016 05:17:34 +0000

Please have a look at the below explanation, I have also tried to explain the graph representation through the adjacency matrix as well.

https://photos.google.com/share/AF1QipPHfLtZq6iE6BXxso_UCwU55cp5cNIcpDc0AC6YM4pkOJ9KMldP-avDcM0o_FG5Ig?key=NXBGZVI0TjM3Q19PX1NYUTNEbDRCS1ZYWXdBOHFn

Here, R1, R2, R3, R4 represents the RED edges and
B1, B2, B3, B4 represents the BLUE edges.

Answered: Graph that has 10 vertices, is 3-colorable and number of edges is maximized

Tue, 23 Aug 2016 13:35:55 +0000

The following graph is a complete tripartite graph K_3,3,4and it is a case of a complete k-partite graph. When drawing this graph, I decomposed the vertices into three disjoint sets. Every vertex of each set graph vertices is adjacent to every vertex in the other two sets. Finally, it can be clearly seen from the graph that the maximum number of edges is 33.

--Updates--

To calculate the number of edges of K3,3,4 (Theoretically), I used the Hand-Shaking Theorem:

The sum of degrees of all vertices = 2 | E |.

The 3 vertices (dark blue) have degree 7, 3 vertices (red) have degree 7, and last 4 vertices (light blue) have degree 6.
Therefore, the sum of the degrees of the vertices of K3,3,4 is (3x7) + (3x7)+ (4×6) = 66.
Thus, the total number of edges is 66 ÷ 2 = 33.

Answered: Color this graph (n=10, m=15)

Tue, 16 Aug 2016 19:43:48 +0000

If we start from the initial vertex, we can assign it a color (say blue)
As we keep traversing through the graph, we assign alternate colors and check for common edge between them.

The graph has 3-chromatic number. The image is shown below.

Answered: symmetry + transitivity => reflexivity, or not?

Tue, 19 Jan 2016 06:58:18 +0000

I agree with the answer above and just want to add something which may be helpful for understanding.

Given a set S = {1,2,3} and a binary relation R = {(1,2), (2,1) , (1,1), (2,2)};

"Reflexivity is not an internal property of a relation. Given a relation R we don't have a sufficient information to decide whether or not it is reflexive. The reason is that we say that R is reflexive on S rather than just reflexive."

To see if relation R is reflexive on S, we need to see for every element a in S, if (a,a) is an element of R, as Prof said, (3,3) is not an element of R, thus symmetry + transitivity !=> reflexivity