Node With Highest Edge Score - Practice Coding Problems

Node With Highest Edge Score - Problem

You are given a directed graph with n nodes labeled from 0 to n-1, where each node has exactly one outgoing edge. This creates a functional graph where every node points to exactly one other node (possibly itself).

The graph is represented by a 0-indexed integer array edges of length n, where edges[i] indicates that there is a directed edge from node i to node edges[i].

The edge score of a node i is defined as the sum of the labels of all the nodes that have an edge pointing to i. In other words, it's the sum of all indices j where edges[j] == i.

Goal: Return the node with the highest edge score. If multiple nodes have the same edge score, return the node with the smallest index.

Example: If edges = [1,0,0,0,0,7,7,5], then:

Node 0 receives edges from nodes 1,2,3,4 → score = 1+2+3+4 = 10
Node 1 receives edge from node 0 → score = 0
Node 7 receives edges from nodes 5,6 → score = 5+6 = 11

Node 7 has the highest score (11), so we return 7.

Input & Output

example_1.py — Basic Case

$ Input: edges = [1,0,0,0,0,7,7,5]

› Output: 7

💡 Note: Node 0 receives edges from nodes 1,2,3,4 (score = 1+2+3+4 = 10). Node 1 receives edge from node 0 (score = 0). Node 5 receives edge from node 7 (score = 7). Node 7 receives edges from nodes 5,6 (score = 5+6 = 11). Node 7 has the highest score of 11.

example_2.py — Tie Breaker

$ Input: edges = [2,0,0,2]

› Output: 0

💡 Note: Node 0 receives edges from nodes 1,2 (score = 1+2 = 3). Node 2 receives edges from nodes 0,3 (score = 0+3 = 3). Both nodes have score 3, but node 0 has smaller index, so we return 0.

example_3.py — Self Loop

$ Input: edges = [0]

› Output: 0

💡 Note: Only one node exists. Node 0 points to itself, so it receives an edge from node 0. Score of node 0 = 0. Return 0.

Constraints

n == edges.length
2 ≤ n ≤ 10⁵
0 ≤ edges[i] ≤ n - 1
edges[i] ≠ i
Edge scores can be very large - use appropriate data types to avoid overflow

Visualization

Tap to expand

Understanding the Visualization

Initialize Score Array

Create an array to track accumulated scores for each node

Process Each Edge

For edge i → edges[i], add voter ID (i) to candidate's score (edges[i])

Find Winner

Scan scores to find maximum value, return smallest index if tied

Key Takeaway

🎯 Key Insight: Instead of repeatedly searching for each node's incoming edges, we can calculate all scores in one pass by directly adding each source node's contribution to its target's running total.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a one-pass array approach with O(n) time complexity. We create a scores array and iterate through edges once, accumulating each node's contribution to its target's score. Finally, we find the node with the maximum score, using the smallest index to break ties. This avoids the O(n²) nested loops of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Array (Optimal)	O(n)	O(n)	Calculate all edge scores in single pass using array to accumulate scores
Brute Force (Nested Loops)	O(n²)	O(1)	For each node, scan all edges to calculate its incoming edge score

One-Pass Array (Optimal) — Algorithm Steps

Create scores array of size n, initialized to 0
For each node i from 0 to n-1:
Add i to scores[edges[i]] (node i contributes to target's score)
Find the node with maximum score (smallest index breaks ties)
Return the node with highest score

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Scores

Create scores array filled with zeros

Process Edge i→edges[i]

Add source node index to target's score

Find Maximum

Scan scores array once to find highest score

Code -

solution.c — C

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

int edgeScore(int* edges, int n) {
    long long* scores = (long long*)calloc(n, sizeof(long long));
    
    // Calculate edge scores in single pass
    for (int i = 0; i < n; i++) {
        scores[edges[i]] += i;
    }
    
    // Find node with maximum score
    long long maxScore = scores[0];
    int result = 0;
    for (int i = 1; i < n; i++) {
        if (scores[i] > maxScore) {
            maxScore = scores[i];
            result = i;
        }
    }
    
    free(scores);
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int edges[100000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        edges[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", edgeScore(edges, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to calculate scores + single pass to find maximum

✓ Linear Growth

Space Complexity

O(n)

Additional array to store edge scores for each node

⚡ Linearithmic Space

25.5K Views

Medium Frequency

~12 min Avg. Time

850 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

One-Pass Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler