Maximum Score of a Node Sequence - Practice Coding Problems

Maximum Score of a Node Sequence - Problem

There is an undirected graph with n nodes, numbered from 0 to n - 1.

You are given a 0-indexed integer array scores of length n where scores[i] denotes the score of node i. You are also given a 2D integer array edges where edges[i] = [ai, bi] denotes that there exists an undirected edge connecting nodes ai and bi.

A node sequence is valid if it meets the following conditions:

There is an edge connecting every pair of adjacent nodes in the sequence.
No node appears more than once in the sequence.

The score of a node sequence is defined as the sum of the scores of the nodes in the sequence.

Return the maximum score of a valid node sequence with a length of 4. If no such sequence exists, return -1.

Input & Output

Example 1 — Basic Valid Sequence

$ Input: scores = [5,2,9,6,7], edges = [[0,1],[1,2],[2,3],[0,2],[3,4]]

› Output: 24

💡 Note: The optimal 4-node sequence is 0→2→3→4 with scores 5+9+6+7=24. All consecutive nodes are connected by edges.

Example 2 — No Valid Sequence

$ Input: scores = [9,20,6,4,11,12], edges = [[0,3],[5,1],[2,3],[5,2]]

› Output: -1

💡 Note: No valid 4-node sequence exists. The graph doesn't have enough connected nodes to form a path of length 4.

Example 3 — Multiple Valid Paths

$ Input: scores = [1,2,3,4], edges = [[0,1],[1,2],[2,3],[0,2],[1,3]]

› Output: 10

💡 Note: Multiple valid paths exist like 0→1→2→3 (score=10) and 0→2→1→3 (score=10). Return the maximum score.

Constraints

n == scores.length
4 ≤ n ≤ 5 × 10⁴
1 ≤ scores[i] ≤ 10⁸
0 ≤ edges.length ≤ 5 × 10⁴
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
There are no duplicate edges.

Visualization

Tap to expand

Understanding the Visualization

Input Graph

Graph with node scores and edges

Find Valid Paths

Enumerate all valid 4-node sequences

Calculate Scores

Sum scores for each valid path

Return Maximum

Return highest score found

Key Takeaway

🎯 Key Insight: Focus on middle edges to efficiently enumerate valid 4-node paths instead of checking all combinations

Asked in

M Meta 15 G Google 12 M Microsoft 8

The key insight is to focus on each edge as the middle connection of a 4-node path rather than checking all combinations. For each edge b-c, we find the best neighbors of b and c to form paths a-b-c-d. Best approach is the optimized middle-edge method with Time: O(E × D²), Space: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All 4-Node Combinations	O(n⁴)	O(1)	Try every possible combination of 4 nodes and check if they form a valid path
Optimized - Focus on Middle Edges	O(E × D²)	O(V + E)	For each edge as the middle connection, find best neighbors to form 4-node paths

Brute Force - Check All 4-Node Combinations — Algorithm Steps

Generate all combinations of 4 nodes
For each combination, check all permutations
Verify if permutation forms a valid connected path
Track maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible sets of 4 nodes

Try Permutations

For each set, try all possible orderings

Validate Path

Check if consecutive nodes are connected

Track Maximum

Keep the highest score found

Code -

solution.c — C

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

int solution(int* scores, int scoresSize, int** edges, int edgesSize) {
    if (scoresSize < 4) return -1;
    
    int maxScore = -1;
    
    // Try all combinations of 4 nodes
    for (int i = 0; i < scoresSize; i++) {
        for (int j = i + 1; j < scoresSize; j++) {
            for (int k = j + 1; k < scoresSize; k++) {
                for (int l = k + 1; l < scoresSize; l++) {
                    int nodes[4] = {i, j, k, l};
                    
                    // Try all permutations (24 permutations of 4 elements)
                    int perms[24][4];
                    int permCount = 0;
                    
                    // Generate all permutations
                    for (int a = 0; a < 4; a++) {
                        for (int b = 0; b < 4; b++) {
                            if (b == a) continue;
                            for (int c = 0; c < 4; c++) {
                                if (c == a || c == b) continue;
                                for (int d = 0; d < 4; d++) {
                                    if (d == a || d == b || d == c) continue;
                                    perms[permCount][0] = nodes[a];
                                    perms[permCount][1] = nodes[b];
                                    perms[permCount][2] = nodes[c];
                                    perms[permCount][3] = nodes[d];
                                    permCount++;
                                }
                            }
                        }
                    }
                    
                    for (int p = 0; p < permCount; p++) {
                        int valid = 1;
                        
                        // Check if this permutation forms valid path
                        for (int step = 0; step < 3 && valid; step++) {
                            int found = 0;
                            for (int e = 0; e < edgesSize; e++) {
                                if ((edges[e][0] == perms[p][step] && edges[e][1] == perms[p][step+1]) ||
                                    (edges[e][1] == perms[p][step] && edges[e][0] == perms[p][step+1])) {
                                    found = 1;
                                    break;
                                }
                            }
                            if (!found) valid = 0;
                        }
                        
                        if (valid) {
                            int score = scores[perms[p][0]] + scores[perms[p][1]] + 
                                       scores[perms[p][2]] + scores[perms[p][3]];
                            if (score > maxScore) maxScore = score;
                        }
                    }
                }
            }
        }
    }
    
    return maxScore;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse scores array
    int scores[1000];
    int scoresSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        scores[scoresSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse edges array
    int edges[1000][2];
    int edgesSize = 0;
    char* ptr = line + 2; // Skip "[["
    while (*ptr && *(ptr+1) != ']') {
        sscanf(ptr, "%d,%d", &edges[edgesSize][0], &edges[edgesSize][1]);
        edgesSize++;
        ptr = strstr(ptr, "],[");
        if (ptr) ptr += 3;
        else break;
    }
    
    int* edgesPtrs[1000];
    for (int i = 0; i < edgesSize; i++) {
        edgesPtrs[i] = edges[i];
    }
    
    printf("%d\n", solution(scores, scoresSize, edgesPtrs, edgesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We check all combinations of 4 nodes from n nodes, then verify connectivity

✓ Linear Growth

Space Complexity

O(1)

Only storing variables for tracking maximum score and current combination

✓ Linear Space

23.4K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All 4-Node Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler