Advantage Shuffle LT870

Posted 2021-11-26 taste-it-own-it-love-it

Given two arrays A and B of equal size, the advantage of A with respect to B is the number of indices i for which A[i] > B[i].

Return any permutation of A that maximizes its advantage with respect to B.

Example 1:

Input: A = [2,7,11,15], B = [1,10,4,11]
Output: [2,11,7,15]

Example 2:

Input: A = [12,24,8,32], B = [13,25,32,11]
Output: [24,32,8,12]

 

Note:

1. 1 <= A.length = B.length <= 10000
2. 0 <= A[i] <= 10^9
3. 0 <= B[i] <= 10^9

 Idea 1. Take adavantage of TreeMap to find the smallest key which is strictly bigger than the given value, for each value in the array, find the least bigger value, if no bigger value, take the smallest element.

Time complexity: O(nlogn)

Space complexity: O(n)

 1 class Solution {
 2     public int[] advantageCount(int[] A, int[] B) {
 3         TreeMap<Integer, Integer> intCnt = new TreeMap<>();
 4         for(int a: A) {
 5             intCnt.put(a, intCnt.getOrDefault(a, 0) + 1);
 6         }
 7         
 8         int[] result = new int[A.length];
 9         for(int i = 0; i < B.length; ++i) {
10             
11             Integer candidate = intCnt.higherKey(B[i]);
12             if(candidate == null) {
13                 candidate = intCnt.firstKey();
14             }
15             result[i] = candidate;
16             intCnt.put(candidate, intCnt.get(candidate)-1);
17             if(intCnt.get(candidate) == 0) {
18                 intCnt.remove(candidate);
19             }
20         }
21         
22         return result;
23     }
24 }

Idea 1.b 田忌赛马 use prority queue to store(value, index) for max in sorted order, if max[A] > max[B], put result[pos[maxB]] = A, otherwise result[pos[maxB]] = min[A], if max[A] can‘t satisfy mx[B], no other values can, min[A] is the most cost-effective choice.

Time complexity: O(nlogn)

Space complexity: O(n)

 1 class Solution {
 2     public int[] advantageCount(int[] A, int[] B) {
 3         
 4         PriorityQueue<int[]> maxHeap = new PriorityQueue<>(
 5             (int[] a, int[] b) -> {
 6                 return Integer.compare(b[0], a[0]);
 7             });
 8         
 9         for(int i = 0; i < B.length; ++i) {
10             maxHeap.add(new int[] {B[i], i});
11         }
12         
13         Arrays.sort(A);
14         int[] result = new int[A.length];
15         
16         int minIndex = 0, maxIndex = A.length-1;
17         while(!maxHeap.isEmpty()) {
18             int[] curr = maxHeap.poll();
19             if(A[maxIndex] > curr[0]) {
20                 result[curr[1]] = A[maxIndex--];
21             }
22             else {
23                 result[curr[1]] = A[minIndex++];
24             }
25         }
26         
27         return result;
28     }
29 }