Largest Color Value in a Directed Graph

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

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

✓ Topological Sort + Dynamic Programming (Optimal)

⏱️ Time: O(V + E) Space: O(V * 26)

This approach combines topological sorting with dynamic programming. First, we perform cycle detection using DFS. If no cycles exist, we use topological sorting to process nodes in dependency order, then use DP to track the maximum count of each color reachable at each node.

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>

char* solution(char* s) {
    int n = strlen(s);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Find first non-'a' character
    int found = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] != 'a') {
            // Change this character to its predecessor
            result[i] = s[i] - 1;
            found = 1;
            break;
        }
    }
    
    if (!found) {
        // All characters are 'a', change the last one to 'z'
        result[n - 1] = 'z';
    }
    
    return result;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

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