Graph Coloring - Problem

Given an undirected graph represented as an adjacency list, color the vertices using the minimum number of colors such that no two adjacent vertices share the same color.

This is a classic Graph Coloring Problem which is NP-hard in general, but can be solved optimally for small graphs using backtracking.

Input: An adjacency list representation where graph[i] contains all neighbors of vertex i.

Output: An array where result[i] is the color assigned to vertex i. Colors are represented as integers starting from 0.

Goal: Use the minimum possible number of colors while ensuring no adjacent vertices have the same color.

Input & Output

Example 1 — Square Graph (4-Cycle)

$ Input: graph = [[1,2],[0,3],[0,3],[1,2]]

› Output: [0,1,2,0]

💡 Note: This is a square/cycle graph with 4 vertices. Vertices 0 and 2 are not adjacent, so they can share color 0. Vertices 1 and 3 are not adjacent, but 1 needs color 1 (can't use 0 like vertex 0), and vertex 3 can use color 0 (not adjacent to vertex 0). Minimum colors needed: 3.

Example 2 — Triangle Graph

$ Input: graph = [[1,2],[0,2],[0,1]]

› Output: [0,1,2]

💡 Note: This is a complete triangle where every vertex is connected to every other vertex. Each vertex needs a unique color, so we need 3 colors: vertex 0 gets color 0, vertex 1 gets color 1, vertex 2 gets color 2.

Example 3 — Disconnected Components

$ Input: graph = [[1],[0],[3],[2]]

› Output: [0,1,0,1]

💡 Note: Two separate edges: 0-1 and 2-3. Since components don't connect, we can reuse colors. Vertices 0 and 2 both get color 0, vertices 1 and 3 both get color 1. Only 2 colors needed.

Constraints

1 ≤ graph.length ≤ 20
0 ≤ graph[i].length ≤ 19
graph[i][j] is a valid vertex index
graph[i] does not contain i (no self-loops)
graph[i] contains no duplicate values

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 f Facebook 15 a Amazon 12

The Graph Coloring Problem seeks to color vertices using minimum colors such that no adjacent vertices share the same color. The key insight is that while finding the optimal solution is NP-hard, backtracking with pruning performs much better than brute force by eliminating invalid branches early. Best approach is backtracking for small graphs or greedy Welsh-Powell for larger graphs. Time: O(k^n) optimal vs O(V²) greedy, Space: O(V)

Common Approaches

✓ Greedy Coloring (Welsh-Powell)

⏱️ Time: O(V² + E) Space: O(V)

Sort vertices by degree (number of connections) in descending order, then color each vertex with the smallest color that doesn't conflict with its already-colored neighbors. This is fast but may not find optimal solution.

Optimized Backtracking with Pruning

⏱️ Time: O(k^n) Space: O(n)

Use backtracking to build a valid coloring one vertex at a time. For each vertex, try only colors that don't conflict with already-colored neighbors. Backtrack immediately when no valid color exists.

Try All Color Combinations

⏱️ Time: O(k^n) Space: O(n)

Try every possible combination of colors for all vertices, starting from using 1 color up to n colors. For each combination, verify that no adjacent vertices share the same color.

Greedy Coloring (Welsh-Powell) — Algorithm Steps

Calculate degree of each vertex (number of neighbors)
Sort vertices by degree in descending order
For each vertex, assign the smallest color not used by colored neighbors
Return the color assignment

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Degree

Order vertices by number of connections (highest first)

Color Greedily

For each vertex, use smallest available color

Fast Result

Get good (but not optimal) coloring quickly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int degree;
    int vertex;
} VertexDegree;

int compare(const void* a, const void* b) {
    VertexDegree* va = (VertexDegree*)a;
    VertexDegree* vb = (VertexDegree*)b;
    return vb->degree - va->degree; // Descending order
}

int* solution(int** graph, int* graphSizes, int n, int* returnSize) {
    *returnSize = n;
    if (n == 0) return NULL;
    
    // Calculate degrees and sort
    VertexDegree* degrees = (VertexDegree*)malloc(n * sizeof(VertexDegree));
    for (int i = 0; i < n; i++) {
        degrees[i].degree = graphSizes[i];
        degrees[i].vertex = i;
    }
    qsort(degrees, n, sizeof(VertexDegree), compare);
    
    int* colors = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) colors[i] = -1;
    
    for (int i = 0; i < n; i++) {
        int vertex = degrees[i].vertex;
        
        // Find used colors by neighbors
        bool usedColors[n];
        for (int j = 0; j < n; j++) usedColors[j] = false;
        
        for (int j = 0; j < graphSizes[vertex]; j++) {
            int neighbor = graph[vertex][j];
            if (colors[neighbor] != -1) {
                usedColors[colors[neighbor]] = true;
            }
        }
        
        // Find first available color
        int color = 0;
        while (color < n && usedColors[color]) {
            color++;
        }
        colors[vertex] = color;
    }
    
    free(degrees);
    return colors;
}

int main() {
    int n = 4;
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSizes = (int*)malloc(n * sizeof(int));
    
    graph[0] = (int*)malloc(2 * sizeof(int));
    graph[0][0] = 1; graph[0][1] = 2; graphSizes[0] = 2;
    graph[1] = (int*)malloc(2 * sizeof(int));
    graph[1][0] = 0; graph[1][1] = 3; graphSizes[1] = 2;
    graph[2] = (int*)malloc(2 * sizeof(int));
    graph[2][0] = 0; graph[2][1] = 3; graphSizes[2] = 2;
    graph[3] = (int*)malloc(2 * sizeof(int));
    graph[3][0] = 1; graph[3][1] = 2; graphSizes[3] = 2;
    
    int returnSize;
    int* result = solution(graph, graphSizes, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V² + E)

O(V log V) for sorting vertices by degree, O(V²) for coloring each vertex checking all neighbors

✓ Linear Growth

Space Complexity

O(V)

Space for degree array, sorted vertices, and color assignment

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Graph Coloring - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Coloring (Welsh-Powell) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler