Best Team With No Conflicts

Best Team With No Conflicts - Problem

You are the manager of a basketball team. For the upcoming tournament, you want to choose the team with the highest overall score. The score of the team is the sum of scores of all the players in the team.

However, the basketball team is not allowed to have conflicts. A conflict exists if a younger player has a strictly higher score than an older player. A conflict does not occur between players of the same age.

Given two arrays scores and ages, where each scores[i] and ages[i] represents the score and age of the ith player, respectively, return the highest overall score of all possible basketball teams.

Input & Output

Example 1 — Basic Team Selection

$ Input: scores = [1,3,5,10,15], ages = [1,2,3,4,5]

› Output: 34

💡 Note: All players have increasing age and score, so we can select all: 1+3+5+10+15 = 34

Example 2 — Conflict Resolution

$ Input: scores = [4,5,6,5], ages = [2,1,2,1]

› Output: 16

💡 Note: Sort by age: [(1,5), (1,5), (2,4), (2,6)]. Best team is players with scores [5,6,5] = 16

Example 3 — Single Player

$ Input: scores = [1], ages = [1]

› Output: 1

💡 Note: Only one player available, so team score is 1

Constraints

1 ≤ ages.length ≤ 1000
ages.length == scores.length
1 ≤ ages[i] ≤ 1000
1 ≤ scores[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to sort players by age first, transforming this into a maximum sum increasing subsequence problem. After sorting, we can use dynamic programming where dp[i] represents the maximum team score ending with player i. Best approach is Sort + DP with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - All Combinations

⏱️ Time: O(2^n × n²) Space: O(n)

Generate all possible subsets of players, check each subset for conflicts (younger player with higher score), and return the maximum sum among valid subsets.

Optimized Sort + DP

⏱️ Time: O(n²) Space: O(n)

Sort by age first, then by score descending within same age. This ensures that when we process players of the same age, higher scores come first, making DP transitions cleaner.

Sort + Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Sort players by age first, then use dynamic programming where dp[i] represents the maximum score ending at player i. This transforms the problem into finding maximum sum increasing subsequence.

Brute Force - All Combinations — Algorithm Steps

Generate all 2^n possible subsets
For each subset, check if conflicts exist
Keep track of maximum sum from valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible team combinations

Check Conflicts

For each team, verify no younger player outscores older player

Find Maximum

Return the highest sum among conflict-free teams

Code -

solution.c — C

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

int solution(int* scores, int* ages, int n) {
    int maxScore = 0;
    
    // Try all possible subsets (2^n combinations)
    for (int mask = 0; mask < (1 << n); mask++) {
        int currentTeam[20][2]; // [age, score] pairs
        int teamSize = 0;
        int currentSum = 0;
        
        // Build current subset
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentTeam[teamSize][0] = ages[i];
                currentTeam[teamSize][1] = scores[i];
                teamSize++;
                currentSum += scores[i];
            }
        }
        
        // Check if this team has conflicts
        int hasConflict = 0;
        for (int i = 0; i < teamSize && !hasConflict; i++) {
            for (int j = i + 1; j < teamSize; j++) {
                int age1 = currentTeam[i][0], score1 = currentTeam[i][1];
                int age2 = currentTeam[j][0], score2 = currentTeam[j][1];
                // Conflict if younger player has higher score
                if ((age1 < age2 && score1 > score2) || (age2 < age1 && score2 > score1)) {
                    hasConflict = 1;
                    break;
                }
            }
        }
        
        if (!hasConflict && currentSum > maxScore) {
            maxScore = currentSum;
        }
    }
    
    return maxScore;
}

int parseNumber(char* str, int* pos) {
    while (str[*pos] && !isdigit(str[*pos]) && str[*pos] != '-') (*pos)++;
    if (!str[*pos]) return 0;
    
    int num = 0;
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    while (str[*pos] && isdigit(str[*pos])) {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    
    return sign * num;
}

int main() {
    char line[1000];
    int scores[1000], ages[1000], n = 0;
    
    // Parse scores array
    fgets(line, sizeof(line), stdin);
    int pos = 0;
    while (pos < strlen(line)) {
        int num = parseNumber(line, &pos);
        if (pos >= strlen(line)) break;
        scores[n++] = num;
    }
    
    // Parse ages array
    fgets(line, sizeof(line), stdin);
    pos = 0;
    int i = 0;
    while (pos < strlen(line) && i < n) {
        int num = parseNumber(line, &pos);
        if (pos >= strlen(line) && num == 0) break;
        ages[i++] = num;
    }
    
    printf("%d\n", solution(scores, ages, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n²)

2^n subsets, each taking O(n²) time to check all pairs for conflicts

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for current subset being evaluated

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~25 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 - All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler