Best Team With No Conflicts - Practice Coding Problems

Best Team With No Conflicts - Problem

Basketball Team Formation

You're a basketball team manager preparing for the championship tournament! Your goal is to select players that will give you the highest total score while avoiding team conflicts.

The Challenge: A conflict occurs when a younger player has a strictly higher score than an older player. Players of the same age never conflict with each other.

Input: Two arrays - scores[i] and ages[i] representing each player's skill score and age
Output: The maximum possible total score of a conflict-free team

Example: If you have players with ages [1,2,3] and scores [5,3,6], you can't pick the youngest player (age 1, score 5) with the oldest (age 3, score 6) because the younger player would have a lower score, which is allowed. But you can't pick players with ages [1,3] and scores [5,3] because that would mean the older player has a lower score.

Input & Output

example_1.py — Basic Case

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

› Output: 34

💡 Note: All players are in increasing order of both age and score, so we can pick all players. Total score = 1+3+5+10+15 = 34.

example_2.py — Conflict Resolution

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

› Output: 16

💡 Note: We can pick players with ages [2,2,1] and scores [4,6,5]. After sorting by age: ages=[1,1,2,2], scores=[5,5,4,6]. The optimal team has score 5+6+5=16.

example_3.py — Edge Case

$ Input: scores = [1,2,3,5], ages = [8,9,10,1]

› Output: 6

💡 Note: The best team is the youngest player (age=1, score=5) and one other player (age=8, score=1), giving total score = 5+1 = 6.

Visualization

Tap to expand

Understanding the Visualization

Sort by Seniority

Arrange players by age to establish clear hierarchy order

Build Optimal Teams

Use DP to find the best team ending with each player, ensuring performance consistency

Select Best Formation

Choose the team configuration with maximum total performance

Key Takeaway

🎯 Key Insight: Sorting by age transforms the problem into finding maximum sum increasing subsequence, making conflicts impossible and enabling efficient DP solution.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting + O(n²) for the DP transitions

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the DP array and sorted pairs

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal solution uses sorting + dynamic programming. First, sort players by age to eliminate age conflicts. Then use DP where dp[i] represents the maximum score achievable ending with player i. For each player, either take them alone or extend a previous valid team. The key insight is that after sorting by age, we only need to ensure scores are non-decreasing, transforming this into a maximum sum increasing subsequence problem with O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sort + Dynamic Programming (Optimal)	O(n²)	O(n)	Sort by age, then use DP to find maximum sum non-decreasing subsequence by score
Brute Force (Try All Combinations)	O(2^n * n^2)	O(n)	Generate all possible team combinations and check each for conflicts

Sort + Dynamic Programming (Optimal) — Algorithm Steps

Create pairs of (age, score) and sort by age first, then by score
Initialize DP array where dp[i] = maximum score ending with player i
For each player i, set dp[i] = scores[i] (can always pick just this player)
For each previous player j where scores[j] ≤ scores[i], update dp[i] = max(dp[i], dp[j] + scores[i])
Return the maximum value in the DP array

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Players

Sort by age first, then by score to eliminate age conflicts

DP Transition

For each player, find best team ending with that player

Build Solution

Maximum value in DP array is our answer

Code -

solution.c — C

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

typedef struct {
    int age;
    int score;
} Player;

int compare(const void* a, const void* b) {
    Player* pa = (Player*)a;
    Player* pb = (Player*)b;
    if (pa->age != pb->age) return pa->age - pb->age;
    return pa->score - pb->score;
}

int bestTeamScore(int* scores, int scoresSize, int* ages, int agesSize) {
    int n = scoresSize;
    Player* players = (Player*)malloc(n * sizeof(Player));
    
    // Create and sort players
    for (int i = 0; i < n; i++) {
        players[i].age = ages[i];
        players[i].score = scores[i];
    }
    qsort(players, n, sizeof(Player), compare);
    
    int* dp = (int*)malloc(n * sizeof(int));
    int maxScore = 0;
    
    for (int i = 0; i < n; i++) {
        dp[i] = players[i].score;
        
        for (int j = 0; j < i; j++) {
            if (players[j].score <= players[i].score) {
                int newScore = dp[j] + players[i].score;
                if (newScore > dp[i]) {
                    dp[i] = newScore;
                }
            }
        }
        
        if (dp[i] > maxScore) {
            maxScore = dp[i];
        }
    }
    
    free(players);
    free(dp);
    return maxScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting + O(n²) for the DP transitions

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the DP array and sorted pairs

⚡ Linearithmic Space

Constraints

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

42.3K Views

Medium-High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sort + Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler