826.MaxProfitAssignment.cs

// 826. Most Profit Assigning Work
// You have n jobs and m workers. You are given three arrays: difficulty, profit, and worker where:

// difficulty[i] and profit[i] are the difficulty and the profit of the ith job, and
// worker[j] is the ability of jth worker (i.e., the jth worker can only complete a job with difficulty at most worker[j]).
// Every worker can be assigned at most one job, but one job can be completed multiple times.
// For example, if three workers attempt the same job that pays $1, then the total profit will be $3. If a worker cannot complete any job, their profit is $0.
// Return the maximum profit we can achieve after assigning the workers to the jobs.

 // Example 1:
// Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
// Output: 100
// Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get a profit of [20,20,30,30] separately.
// Example 2:
// Input: difficulty = [85,47,57], profit = [24,66,99], worker = [40,25,25]
// Output: 0

// Constraints:
// n == difficulty.length
// n == profit.length
// m == worker.length
// 1 <= n, m <= 104
// 1 <= difficulty[i], profit[i], worker[i] <= 105

public class Solution {
    public int MaxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
    
        Array.Sort(difficulty, profit);
        Array.Sort(worker);

        int netProfit = 0;
        int maxProfit = 0;
        int k = 0;

        foreach (int w in worker) {
            while (k < difficulty.Length && w >= difficulty[k]) {
                maxProfit = Math.Max(maxProfit, profit[k]);
                k++;
            }
            netProfit += maxProfit;
        }

        return netProfit;
    }
}


public class Solution {
    public int MaxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
        List<int[]> diffProfit = new List<int[]>();
        for (int i = 0; i < difficulty.Length; i++) {
            diffProfit.Add(new int[] { difficulty[i], profit[i] });
        }

        // Sort by difficulty first, then by profit in descending order
        diffProfit.Sort((a, b) => {
            if (a[0] == b[0]) return b[1].CompareTo(a[1]);
            return a[0].CompareTo(b[0]);
        });

        Array.Sort(worker);

        int netProfit = 0;
        int maxProfit = 0;
        int k = 0;

        foreach (int w in worker) {
            while (k < diffProfit.Count && w >= diffProfit[k][0]) {
                maxProfit = Math.Max(maxProfit, diffProfit[k][1]);
                k++;
            }
            netProfit += maxProfit;
        }

        return netProfit;
    }
}