GATE-CS-2007 Problem 13

This problem is related to graph theory and asks the programmer to design an algorithm that can identify the minimum number of colors required to color the vertices of a given graph such that no two adjacent vertices have the same color.

Problem Statement

Let G be an undirected graph with n nodes and m edges. The vertices are numbered from 1 to n. The minimum number of colors required to color the vertices of G such that no two adjacent vertices have the same color is called the chromatic number of G, denoted by χ(G).

Design an algorithm to find χ(G). Your algorithm should run in time O(n^2).

Solution

To solve this problem, we need to use the greedy coloring algorithm. First, we assign the first vertex a color. Then, for each subsequent vertex, we assign it the lowest numbered color that is not already used by its neighbors. This algorithm guarantees an optimal coloring using at most χ(G) colors.

The algorithm can be implemented using the following pseudocode:

Input: A graph G with n nodes and m edges
Output: The chromatic number of G

1. Assign color 1 to vertex 1.
2. For each vertex v in the graph, do the following:
   a. Let S be the set of colors used by v's neighbors.
   b. Assign v the lowest numbered color that is not in S.
3. Return the maximum color used in the graph.

The time complexity of this algorithm is O(n^2) because we need to iterate over all vertices and their neighbors.

Code

def chromatic_number(graph):
    colors = [0] * len(graph)
    colors[0] = 1

    for i in range(1, len(graph)):
        used_colors = set(colors[j] for j in range(len(graph)) if graph[i][j] == 1)
        for j in range(1, len(graph)):
            if j not in used_colors:
                colors[i] = j
                break

    return max(colors)

Conclusion

In summary, the greedy coloring algorithm is used to solve the chromatic number problem. The algorithm assigns colors to vertices in a way that guarantees an optimal coloring using at most χ(G) colors. The time complexity of the algorithm is O(n^2), which is efficient for most practical purposes.