Largest Color Value in a Directed Graph - Practice Coding Problems

Largest Color Value in a Directed Graph - Problem

Graph Coloring Path Challenge: You're given a directed graph where each node has a specific color (represented by lowercase letters). Your mission is to find the most dominant color along any valid path in the graph.

The Problem: Given n colored nodes numbered 0 to n-1 and a string colors where colors[i] represents the color of node i, plus an array of directed edges, you need to:

1. Find all valid paths in the graph (following directed edges)
2. For each path, count the frequency of each color
3. The "color value" of a path is the count of its most frequent color
4. Return the maximum color value among all paths

Important: If the graph contains a cycle, return -1 (since cycles would allow infinite path lengths).

Example: If a path goes through nodes with colors "abbac", the most frequent color is 'a' (appears 2 times), so this path has color value 2.

Input & Output

example_1.py — Basic Path

$ Input: colors = "abaca", edges = [[0,1],[0,2],[2,3],[3,4]]

› Output: 3

💡 Note: The path 0 -> 2 -> 3 -> 4 produces the sequence "acaa". Color 'a' appears 3 times, which is the maximum.

example_2.py — Multiple Paths

$ Input: colors = "a", edges = [[0,0]]

› Output: -1

💡 Note: There is a cycle from 0 to 0, so we return -1.

example_3.py — Single Node

$ Input: colors = "abc", edges = []

› Output: 1

💡 Note: No edges means each node forms its own path. The maximum color value is 1 (any single node).

Constraints

1 ≤ n ≤ 10⁵
0 ≤ m ≤ 10⁵
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
colors consists of lowercase English letters

Visualization

Tap to expand

Step 1: Identify entrance rooms (no prerequisites)• Step 2: Check for circular routes that trap visitors• Step 3: Calculate max theme exposure for each room• Result: Best tour gives 3 Art experiences (A→B→A→C→A)MAX3A

Understanding the Visualization

Map the Museum

Create a map of all rooms and their connections, noting which rooms have no entrance requirements

Detect Circular Routes

Use topological sorting to ensure no visitor gets trapped in circular paths

Plan Optimal Routes

For each room, calculate the maximum theme exposure possible from all routes leading to it

Find Best Experience

Return the highest theme exposure value achievable across all possible museum tours

Key Takeaway

🎯 Key Insight: By processing museum rooms in dependency order (topological sort), we can efficiently calculate the maximum theme exposure without getting trapped in circular routes, ensuring every visitor gets the optimal museum experience.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses Topological Sort + Dynamic Programming. First, detect cycles using Kahn's algorithm - if a cycle exists, return -1. Then process nodes in topological order while maintaining a DP table where dp[node][color] represents the maximum count of each color in paths ending at that node. The answer is the maximum value in the entire DP table with O(V + E) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Topological Sort + Dynamic Programming (Optimal)	O(V + E)	O(V * 26)	Use topological sorting with DP to efficiently find maximum color values

Topological Sort + Dynamic Programming (Optimal) — Algorithm Steps

Build adjacency list and calculate in-degrees for all nodes
Perform topological sort using Kahn's algorithm (BFS with queue)
If we can't process all nodes, a cycle exists - return -1
For each node in topological order, update DP table with maximum color counts
Return the maximum value across all nodes and colors in DP table

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list and calculate in-degrees

Topological Sort

Process nodes in dependency order using Kahn's algorithm

Dynamic Programming

Update DP table for maximum color counts at each node

Find Maximum

Return the maximum value across all nodes and colors

Code -

solution.c — C

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

int largestPathValue(char* colors, int** edges, int edgesSize, int* edgesColSize) {
    int n = strlen(colors);
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSizes = (int*)calloc(n, sizeof(int));
    int* inDegree = (int*)calloc(n, sizeof(int));
    
    // Count outgoing edges
    for (int i = 0; i < edgesSize; i++) {
        graphSizes[edges[i][0]]++;
        inDegree[edges[i][1]]++;
    }
    
    // Allocate memory
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(graphSizes[i] * sizeof(int));
        graphSizes[i] = 0;
    }
    
    // Fill adjacency list
    for (int i = 0; i < edgesSize; i++) {
        graph[edges[i][0]][graphSizes[edges[i][0]]++] = edges[i][1];
    }
    
    // Topological sort
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = 0;
    
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            queue[rear++] = i;
        }
    }
    
    int* topoOrder = (int*)malloc(n * sizeof(int));
    int topoCount = 0;
    
    while (front < rear) {
        int node = queue[front++];
        topoOrder[topoCount++] = node;
        
        for (int i = 0; i < graphSizes[node]; i++) {
            int neighbor = graph[node][i];
            inDegree[neighbor]--;
            if (inDegree[neighbor] == 0) {
                queue[rear++] = neighbor;
            }
        }
    }
    
    if (topoCount != n) {
        free(queue);
        free(topoOrder);
        return -1;
    }
    
    // DP
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(26, sizeof(int));
    }
    
    for (int t = 0; t < topoCount; t++) {
        int node = topoOrder[t];
        int colorIdx = colors[node] - 'a';
        dp[node][colorIdx] = 1;
        
        // Update from predecessors
        for (int prev = 0; prev < n; prev++) {
            int hasEdge = 0;
            for (int i = 0; i < graphSizes[prev]; i++) {
                if (graph[prev][i] == node) {
                    hasEdge = 1;
                    break;
                }
            }
            
            if (hasEdge) {
                for (int color = 0; color < 26; color++) {
                    int newVal = (color == colorIdx) ? dp[prev][color] + 1 : dp[prev][color];
                    if (newVal > dp[node][color]) {
                        dp[node][color] = newVal;
                    }
                }
            }
        }
    }
    
    int maxValue = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 26; j++) {
            if (dp[i][j] > maxValue) {
                maxValue = dp[i][j];
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
        free(dp[i]);
    }
    free(graph);
    free(graphSizes);
    free(inDegree);
    free(queue);
    free(topoOrder);
    free(dp);
    
    return maxValue;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Topological sort takes O(V + E), DP updates take O(V * E * 26) in worst case

✓ Linear Growth

Space Complexity

O(V * 26)

DP table stores maximum count for each of 26 colors at each vertex

✓ Linear Space

31.8K Views

Medium Frequency

~25 min Avg. Time

982 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Topological Sort + Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler