1class Solution {
2    public long maxPoints(int[] technique1, int[] technique2, int k) {
3        int n = technique1.length;
4
5        // Create an index array so we can sort indices without disturbing
6        // the original input arrays.
7        Integer[] indices = new Integer[n];
8        Arrays.setAll(indices, i -> i);
9
10        // Sort indices in descending order by the "gain" of switching from
11        // technique2 to technique1, i.e. (technique1[i] - technique2[i]).
12        // The largest gains come first.
13        Arrays.sort(indices,
14                (a, b) -> (technique1[b] - technique2[b]) - (technique1[a] - technique2[a]));
15
16        // Start by assuming every element uses technique2.
17        long answer = 0;
18        for (int value : technique2) {
19            answer += value;
20        }
21
22        // For the first k indices (the ones with the largest gain) we are
23        // forced/allowed to switch to technique1, regardless of sign.
24        for (int i = 0; i < k; i++) {
25            int index = indices[i];
26            answer -= technique2[index];
27            answer += technique1[index];
28        }
29
30        // For the remaining indices, only switch to technique1 when it does
31        // not decrease the total (i.e. the gain is non-negative).
32        for (int i = k; i < n; i++) {
33            int index = indices[i];
34            if (technique1[index] >= technique2[index]) {
35                answer -= technique2[index];
36                answer += technique1[index];
37            }
38        }
39
40        return answer;
41    }
42}
43

1class Solution {
2public:
3    long long maxPoints(vector<int>& technique1, vector<int>& technique2, int k) {
4        int n = technique1.size();
5
6        // Create an index array [0, 1, 2, ..., n-1]
7        vector<int> indices(n);
8        iota(indices.begin(), indices.end(), 0);
9
10        // Sort indices by the gain (technique1[i] - technique2[i]) in descending order.
11        // The indices with the largest gain come first, so we can prioritize
12        // applying technique1 on them within the limit k.
13        sort(indices.begin(), indices.end(), [&](int i, int j) {
14            return (technique1[i] - technique2[i]) > (technique1[j] - technique2[j]);
15        });
16
17        // Start by assuming technique2 is applied to every element.
18        long long answer = 0;
19        for (int value : technique2) {
20            answer += value;
21        }
22
23        // For the first k elements (those with the highest gain), we are forced
24        // (or at least allowed) to switch from technique2 to technique1.
25        for (int i = 0; i < k; ++i) {
26            int index = indices[i];
27            answer -= technique2[index];   // Remove the technique2 contribution
28            answer += technique1[index];   // Add the technique1 contribution
29        }
30
31        // For the remaining elements, switch to technique1 only when it is
32        // beneficial (i.e., technique1 yields at least as much as technique2).
33        for (int i = k; i < n; ++i) {
34            int index = indices[i];
35            if (technique1[index] >= technique2[index]) {
36                answer -= technique2[index];   // Remove the technique2 contribution
37                answer += technique1[index];   // Add the technique1 contribution
38            }
39        }
40
41        return answer;
42    }
43};
44

1/**
2 * Calculates the maximum total points achievable.
3 *
4 * Each element can contribute either its value from `technique1` or `technique2`.
5 * We must use `technique1` for exactly at least `k` elements (the ones where the
6 * gain from switching to technique1 is largest). For the remaining elements,
7 * we freely pick whichever technique yields a higher value.
8 *
9 * @param technique1 - Point values when using the first technique.
10 * @param technique2 - Point values when using the second technique.
11 * @param k - The minimum number of elements that must use technique1.
12 * @returns The maximum total points obtainable.
13 */
14function maxPoints(technique1: number[], technique2: number[], k: number): number {
15    const length: number = technique1.length;
16
17    // Index array used to order elements by their "gain" of switching to technique1.
18    const indices: number[] = Array.from({ length }, (_, i) => i);
19
20    // Sort indices in descending order of (technique1 - technique2).
21    // The largest gains come first, so the first k indices are the best
22    // candidates to forcibly assign technique1.
23    indices.sort(
24        (i, j) =>
25            (technique1[j] - technique2[j]) - (technique1[i] - technique2[i]),
26    );
27
28    // Start by assuming every element uses technique2.
29    let answer: number = technique2.reduce((sum, value) => sum + value, 0);
30
31    // For the top k elements (largest gain), force the use of technique1
32    // regardless of whether it is beneficial.
33    for (let i = 0; i < k; i++) {
34        const index: number = indices[i];
35        answer -= technique2[index];
36        answer += technique1[index];
37    }
38
39    // For the remaining elements, switch to technique1 only when it gives
40    // a value greater than or equal to technique2.
41    for (let i = k; i < length; i++) {
42        const index: number = indices[i];
43        if (technique1[index] >= technique2[index]) {
44            answer -= technique2[index];
45            answer += technique1[index];
46        }
47    }
48
49    return answer;
50}
51