Best Team With No Conflicts solution and explanation

def bestTeamScore(scores, ages):
    players = sorted(zip(ages, scores))
    dp = [0] * len(scores)
    max_score = 0

    for i in range(len(scores)):
        dp[i] = players[i][1]
        for j in range(i):
            if players[j][1] <= players[i][1]:
                dp[i] = max(dp[i], dp[j] + players[i][1])
        max_score = max(max_score, dp[i])

    return max_score

import java.util.Arrays;

public class Solution {
    public int bestTeamScore(int[] scores, int[] ages) {
        int n = scores.length;
        int[][] players = new int[n][2];
        for (int i = 0; i < n; i++) {
            players[i][0] = ages[i];
            players[i][1] = scores[i];
        }
        Arrays.sort(players, (a, b) -> a[0] == b[0] ? Integer.compare(a[1], b[1]) : Integer.compare(a[0], b[0]));

        int[] dp = new int[n];
        int maxScore = 0;
        for (int i = 0; i < n; i++) {
            dp[i] = players[i][1];
            for (int j = 0; j < i; j++) {
                if (players[j][1] <= players[i][1]) {
                    dp[i] = Math.max(dp[i], dp[j] + players[i][1]);
                }
            }
            maxScore = Math.max(maxScore, dp[i]);
        }
        return maxScore;
    }
}

#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
    int bestTeamScore(vector<int>& scores, vector<int>& ages) {
        int n = scores.size();
        vector<pair<int, int>> players;
        for (int i = 0; i < n; ++i) {
            players.push_back({ages[i], scores[i]});
        }
        sort(players.begin(), players.end());

        vector<int> dp(n);
        int maxScore = 0;
        for (int i = 0; i < n; ++i) {
            dp[i] = players[i].second;
            for (int j = 0; j < i; ++j) {
                if (players[j].second <= players[i].second) {
                    dp[i] = max(dp[i], dp[j] + players[i].second);
                }
            }
            maxScore = max(maxScore, dp[i]);
        }
        return maxScore;
    }
};

function bestTeamScore(scores, ages) {
    const players = scores.map((score, i) => [ages[i], score]);
    players.sort(([age1, score1], [age2, score2]) => age1 - age2 || score1 - score2);

    const dp = Array(scores.length).fill(0);
    let maxScore = 0;

    for (let i = 0; i < scores.length; i++) {
        dp[i] = players[i][1];
        for (let j = 0; j < i; j++) {
            if (players[j][1] <= players[i][1]) {
                dp[i] = Math.max(dp[i], dp[j] + players[i][1]);
            }
        }
        maxScore = Math.max(maxScore, dp[i]);
    }

    return maxScore;
}

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

int compare(const void* a, const void* b) {
    int* x = (int*)a;
    int* y = (int*)b;
    return (x[0] == y[0]) ? (x[1] - y[1]) : (x[0] - y[0]);
}

int bestTeamScore(int* scores, int scoresSize, int* ages) {
    int players[scoresSize][2];
    for (int i = 0; i < scoresSize; ++i) {
        players[i][0] = ages[i];
        players[i][1] = scores[i];
    }
    qsort(players, scoresSize, sizeof(players[0]), compare);

    int dp[scoresSize];
    int maxScore = 0;
    for (int i = 0; i < scoresSize; ++i) {
        dp[i] = players[i][1];
        for (int j = 0; j < i; ++j) {
            if (players[j][1] <= players[i][1]) {
                if (dp[j] + players[i][1] > dp[i]) {
                    dp[i] = dp[j] + players[i][1];
                }
            }
        }
        if (dp[i] > maxScore) {
            maxScore = dp[i];
        }
    }
    return maxScore;
}

public class Solution {
    public int BestTeamScore(int[] scores, int[] ages) {
        var players = new List<(int age, int score)>();
        for (int i = 0; i < scores.Length; i++) {
            players.Add((ages[i], scores[i]));
        }
        players = players.OrderBy(p => p.age).ThenBy(p => p.score).ToList();

        var dp = new int[scores.Length];
        int maxScore = 0;

        for (int i = 0; i < scores.Length; i++) {
            dp[i] = players[i].score;
            for (int j = 0; j < i; j++) {
                if (players[j].score <= players[i].score) {
                    dp[i] = Math.Max(dp[i], dp[j] + players[i].score);
                }
            }
            maxScore = Math.Max(maxScore, dp[i]);
        }

        return maxScore;
    }
}

function bestTeamScore(scores: number[], ages: number[]): number {
    const arr = ages.map((age, i) => [age, scores[i]]);
    arr.sort((a, b) => (a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]));
    const n = arr.length;
    const f = new Array(n).fill(0);
    for (let i = 0; i < n; ++i) {
        for (let j = 0; j < i; ++j) {
            if (arr[i][1] >= arr[j][1]) {
                f[i] = Math.max(f[i], f[j]);
            }
        }
        f[i] += arr[i][1];
    }
    return Math.max(...f);
}

func bestTeamScore(scores []int, ages []int) int {
	n := len(ages)
	arr := make([][2]int, n)
	for i := range ages {
		arr[i] = [2]int{scores[i], ages[i]}
	}
	sort.Slice(arr, func(i, j int) bool {
		a, b := arr[i], arr[j]
		return a[0] < b[0] || a[0] == b[0] && a[1] < b[1]
	})
	f := make([]int, n)
	for i := range arr {
		for j := 0; j < i; j++ {
			if arr[i][1] >= arr[j][1] {
				f[i] = max(f[i], f[j])
			}
		}
		f[i] += arr[i][0]
	}
	return slices.Max(f)
}