Maximum Score of a Node Sequence - Practice Coding Problems

Maximum Score of a Node Sequence - Problem

Imagine you're exploring a network of interconnected cities, where each city has a popularity score. Your goal is to plan the perfect 4-city tour that maximizes the total score!

You're given:

An undirected graph with n nodes (cities) numbered from 0 to n-1
A scores array where scores[i] represents the popularity score of city i
An edges array where each edges[i] = [a, b] represents a direct road between cities a and b

Your tour must follow these rules:

Connected Path: You can only travel between directly connected cities
No Revisits: Each city can only be visited once in your tour
Exactly 4 Cities: Your tour must visit exactly 4 different cities

Goal: Find the tour of 4 cities with the maximum total popularity score. If no valid 4-city tour exists, return -1.

Input & Output

example_1.py — Basic Connected Path

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

› Output: 24

💡 Note: The optimal 4-node path is 0 → 2 → 1 → 3 with scores [5,9,2,8] totaling 24. This path follows edges: (0,2), (2,1), (1,3), creating a valid sequence where each consecutive pair is connected.

example_2.py — Linear Chain

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

› Output: -1

💡 Note: No valid 4-node sequence exists. The graph has disconnected components and no path of length 4 where all consecutive nodes are connected by edges. Node 3 is a hub connected to 0,1,5 but these don't form a 4-node path.

example_3.py — Multiple Valid Paths

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

› Output: 4

💡 Note: The graph forms a linear path 0-1-2-3-4. The only valid 4-node sequences are consecutive segments like 0→1→2→3 or 1→2→3→4, each with total score 1+1+1+1 = 4.

Visualization

Tap to expand

Bridge Focus: Every 4-restaurant tour has a middle connection (B→C)2. Smart Search: Try each street as potential bridge connection3. Optimal Endpoints: Find highest-rated restaurants at each end4. Efficiency: Sort connections by rating for quick selectionResult: A(9.2) → B(7.8) → C(8.5) → D(9.7) = Total Score: 35.2 ⭐Time Complexity: O(n² + m) vs Brute Force: O(n⁴)

Understanding the Visualization

Map the Connections

First, map out which restaurants are directly connected by walkable streets

Identify Bridge Points

Realize that any 4-restaurant tour has two middle restaurants that act as a bridge

Find Best Endpoints

For each potential bridge connection, find the highest-rated restaurants on each end

Calculate Optimal Route

Compare all possible bridge-based routes to find the maximum total rating

Key Takeaway

🎯 Key Insight: By recognizing that every 4-node path has a middle edge structure, we can dramatically reduce the search space from O(n⁴) to O(n² + m), making the algorithm efficient enough for large graphs while guaranteeing the optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O(n² + m)

O(n²) for sorting all adjacency lists, O(m) for iterating through all edges where m is number of edges

⚠ Quadratic Growth

Space Complexity

O(n²)

Space for adjacency lists containing all graph connections

⚠ Quadratic Space

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
No duplicate edges exist
The graph may be disconnected

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution leverages the key insight that any 4-node path has the structure A-B-C-D, where B-C forms the middle edge. Instead of checking all possible combinations, we iterate through each edge as a potential middle connection and find the highest-scoring neighbors on each side. By sorting neighbors by score, we can efficiently identify the best endpoints, achieving O(n² + m) time complexity compared to the brute force O(n⁴) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Middle Edge Optimization	O(n² + m)	O(n²)	Focus on middle edges and find best neighbors on each side
Brute Force (All Path Enumeration)	O(n^4)	O(n^2)	Check every possible 4-node sequence and validate connectivity

Middle Edge Optimization — Algorithm Steps

Build adjacency list and sort neighbors by score for each node
For each edge (u,v), consider it as the middle edge B-C
Find the best neighbor of u (excluding v) as node A
Find the best neighbor of v (excluding u) as node D
Calculate total score and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Structure

Recognize that any 4-node path has form A-B-C-D with middle edge B-C

Sort Neighbors

Sort each node's neighbors by score for quick access to best options

Try Middle Edges

For each edge as potential B-C, find best A and D neighbors

Optimize Selection

Use sorted order to quickly find highest scoring valid paths

Code -

solution.c — C

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

int compare(const void *a, const void *b, void *scores) {
    int *s = (int*)scores;
    int idx_a = *(int*)a;
    int idx_b = *(int*)b;
    return s[idx_b] - s[idx_a];  // Descending order
}

int maximumScore(int* scores, int scoresSize, int** edges, int edgesSize, int* edgesColSize) {
    // Build adjacency list
    int** graph = (int**)malloc(scoresSize * sizeof(int*));
    int* graphSize = (int*)calloc(scoresSize, sizeof(int));
    
    // Count neighbors for each node
    for (int i = 0; i < edgesSize; i++) {
        graphSize[edges[i][0]]++;
        graphSize[edges[i][1]]++;
    }
    
    // Allocate memory for each adjacency list
    for (int i = 0; i < scoresSize; i++) {
        graph[i] = (int*)malloc(graphSize[i] * sizeof(int));
        graphSize[i] = 0;  // Reset to use as index
    }
    
    // Fill adjacency list
    for (int i = 0; i < edgesSize; i++) {
        graph[edges[i][0]][graphSize[edges[i][0]]++] = edges[i][1];
        graph[edges[i][1]][graphSize[edges[i][1]]++] = edges[i][0];
    }
    
    int maxScore = -1;
    
    // Try each edge as the middle edge of 4-node path
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        
        // Try u-v as middle edge
        for (int j = 0; j < graphSize[u]; j++) {
            int a = graph[u][j];
            if (a == v) continue;
            
            for (int k = 0; k < graphSize[v]; k++) {
                int d = graph[v][k];
                if (d == u || d == a) continue;
                
                int totalScore = scores[a] + scores[u] + scores[v] + scores[d];
                if (totalScore > maxScore) {
                    maxScore = totalScore;
                }
                break;
            }
            break;
        }
        
        // Try v-u as middle edge
        for (int j = 0; j < graphSize[v]; j++) {
            int a = graph[v][j];
            if (a == u) continue;
            
            for (int k = 0; k < graphSize[u]; k++) {
                int d = graph[u][k];
                if (d == v || d == a) continue;
                
                int totalScore = scores[a] + scores[v] + scores[u] + scores[d];
                if (totalScore > maxScore) {
                    maxScore = totalScore;
                }
                break;
            }
            break;
        }
    }
    
    // Free memory
    for (int i = 0; i < scoresSize; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    
    return maxScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + m)

O(n²) for sorting all adjacency lists, O(m) for iterating through all edges where m is number of edges

⚠ Quadratic Growth

Space Complexity

O(n²)

Space for adjacency lists containing all graph connections

⚠ Quadratic Space

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
No duplicate edges exist
The graph may be disconnected

48.3K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Middle Edge Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler