Maximum Star Sum of a Graph - Practice Coding Problems

Maximum Star Sum of a Graph - Problem

Array Greedy Graph Sorting Heap (Priority Queue) Medium

Imagine you're analyzing a social network where each person has a value (representing their influence or importance), and you want to find the most valuable "star-shaped" community.

You're given an undirected graph with n nodes numbered from 0 to n-1, where each node i has a value vals[i]. The graph is defined by edges connecting these nodes.

A star graph is a special subgraph where:

There's one center node
All other nodes in the star are directly connected to this center
No edges exist between the non-center nodes

The star sum is the total value of all nodes in the star (center + its neighbors). Your goal is to find the maximum possible star sum when the star contains at most k edges.

Key insight: Since we want to maximize the sum, for each potential center node, we should greedily select its k highest-valued neighbors (if they have positive values).

Input & Output

example_1.py — Basic Star Graph

$ Input: vals = [1,2,3,4,10,-10,-20], edges = [[0,1],[1,2],[1,3],[3,4],[3,5],[3,6]], k = 2

› Output: 16

💡 Note: The optimal star has center at node 3 (val=4). Its neighbors are [1,4,5,6] with values [2,10,-10,-20]. We greedily select the top 2 positive neighbors: 4 (val=10) and 1 (val=2). Star sum = 4 + 10 + 2 = 16.

example_2.py — Single Node Best

$ Input: vals = [-5], edges = [], k = 0

› Output: -5

💡 Note: Only one node exists with value -5. Since k=0, we can't include any edges, so the star is just the single node with sum -5.

example_3.py — All Negative Neighbors

$ Input: vals = [5,-1,-2,-3,-4], edges = [[0,1],[0,2],[0,3],[0,4]], k = 2

› Output: 5

💡 Note: Node 0 (val=5) has neighbors with all negative values. Since adding negative neighbors decreases the sum, the optimal star contains only the center node 0, giving sum = 5.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ min(2 × 10⁵, n × (n - 1) / 2)
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
There are no repeated edges
-10⁴ ≤ vals[i] ≤ 10⁴
0 ≤ k ≤ n - 1

Visualization

Tap to expand

Understanding the Visualization

Choose Center

Pick any node as the center of your star network

Rank Connections

Sort all neighbors by their value/influence in descending order

Greedy Selection

Select up to k neighbors, but only those with positive values

Calculate Value

Sum the center's value plus all selected neighbors' values

Try All Centers

Repeat for every possible center and keep the maximum sum

Key Takeaway

🎯 Key Insight: The greedy approach works perfectly here because we're trying to maximize a sum, and there's never a reason to pick a lower-valued neighbor when a higher-valued one is available. This transforms a potentially complex optimization problem into a simple sorting and selection task!

Asked in

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

The optimal approach uses a greedy strategy: for each potential center node, sort its neighbors by value in descending order and select up to k neighbors with positive values. This works because adding any positive neighbor improves the sum, so we should always choose the highest-valued ones first. Time complexity: O(E log D) where E is edges and D is max degree.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Selection (Optimal)	O(E log D)	O(E)	For each center, sort neighbors by value and greedily pick top k positive ones
Brute Force (Try All Combinations)	O(n × 2^d)	O(n + E)	For each node as center, try all combinations of its neighbors up to k

Greedy Selection (Optimal) — Algorithm Steps

Build adjacency list from the edges
Initialize max_sum to track the best result
For each node as potential center:
Sort its neighbors by their values in descending order
Greedily add up to k neighbors with positive values
Update max_sum with the best star sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Center

Select a node as the center of the star

Sort Neighbors

Sort all neighbors by their values in descending order

Greedy Selection

Pick up to k neighbors with positive values, starting from highest

Calculate Sum

Sum center value plus selected neighbor values

Try Next Center

Repeat for all possible centers and track maximum

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a);  // Descending order
}

typedef struct {
    int* neighbors;
    int size;
    int capacity;
} AdjList;

int maxStarSum(int* vals, int valsSize, int** edges, int edgesSize, int* edgesColSize, int k) {
    // Build adjacency list
    AdjList* graph = (AdjList*)calloc(valsSize, sizeof(AdjList));
    
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        
        // Add b to a's list
        if (graph[a].size == graph[a].capacity) {
            graph[a].capacity = graph[a].capacity == 0 ? 1 : graph[a].capacity * 2;
            graph[a].neighbors = (int*)realloc(graph[a].neighbors, graph[a].capacity * sizeof(int));
        }
        graph[a].neighbors[graph[a].size++] = b;
        
        // Add a to b's list
        if (graph[b].size == graph[b].capacity) {
            graph[b].capacity = graph[b].capacity == 0 ? 1 : graph[b].capacity * 2;
            graph[b].neighbors = (int*)realloc(graph[b].neighbors, graph[b].capacity * sizeof(int));
        }
        graph[b].neighbors[graph[b].size++] = a;
    }
    
    int maxSum = INT_MIN;
    
    // Try each node as center
    for (int center = 0; center < valsSize; center++) {
        // Start with center value
        int currentSum = vals[center];
        
        // Get neighbor values and sort them
        int* neighborValues = (int*)malloc(graph[center].size * sizeof(int));
        for (int i = 0; i < graph[center].size; i++) {
            neighborValues[i] = vals[graph[center].neighbors[i]];
        }
        qsort(neighborValues, graph[center].size, sizeof(int), compare);
        
        // Greedily add up to k neighbors with positive values
        int edgesUsed = 0;
        for (int i = 0; i < graph[center].size && edgesUsed < k; i++) {
            if (neighborValues[i] > 0) {
                currentSum += neighborValues[i];
                edgesUsed++;
            }
        }
        
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
        
        free(neighborValues);
    }
    
    // Clean up
    for (int i = 0; i < valsSize; i++) {
        free(graph[i].neighbors);
    }
    free(graph);
    
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(E log D)

E edges to build graph, then for each node we sort its neighbors (D = max degree), total sorting time is O(E log D)

⚡ Linearithmic

Space Complexity

O(E)

Space for adjacency list storing all E edges

✓ Linear Space

67.4K Views

Medium-High Frequency

~18 min Avg. Time

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

Greedy Selection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler