Рубрики
Без рубрики

Решение: Advantage Shuffle

Это является частью серии пояснений решения LeetCode (индекс). Если вам понравилось это решение или Фу … помечены алгоритмами, JavaScript, Java, Python.

Решения LeetCode (161 часть серии)

Это является частью серии объяснений решения LeetCode ( index ). Если вам понравилось это решение или нашел его полезным, Пожалуйста, как этот пост и/или УПОТАТЬ Мое решение пост на форумах LeetCode Отказ

Проблема летета # 870 (средний): Advantage Shuffle

Описание:

( Перейти к : Идея решения Код : JavaScript | Python |. Java |. C ++

Учитывая две массивы A и B равного размера, Преимущество А Что касается B это количество показателей Я для чего [I] > Б [я] Отказ

Вернуть любой Перестановка А это максимизирует свое преимущество в отношении B Отказ

Примеры:

Вход: A = [ 2,7,11,15], B = [1,10,4,11]
Выход: [2,11,7,15]
Вход: A = [12,24,8,32], B = [13,25,32,11]
Выход: [24,32,8,12]

Ограничения:

  • 1.Length.Length
  • 0 [я] ^ 9
  • 0 [я] ^ 9

Идея:

( Перейти к : Описание проблемы Код : JavaScript | Python |. Java |. C ++

Общий принцип здесь легко понять: для каждого значения в B Мы в идеале хотим выбрать номер от А то есть просто выше, чтобы соответствовать этому. Наивный способ сделать это потребует сортировки А Затем, затем, итерация через него, пока не найду идеальный номер, а затем удалить этот номер из A и переместить его на массив ответа ( ANS ) на Сложность времени O (n ^ 2) Отказ

Мы могли бы использовать Бинарный поиск вместо прямой итерации, которая бросила бы общую сложность времени на O (n * log n) Соответствие сложности сортировки времени. Вопрос, который остается, однако, это избавление от элементов А может быть трудоемким. ( Примечание: этот метод на самом деле хорошо работает в Python; см. Код ниже. )

Вместо этого, если бы у нас было отсортировано B Кроме того, мы могли просто сопоставить значения очень легко в порядке убывания. Если самая большая оставшаяся стоимость А больше, чем наибольшее оставшееся значение B Затем используйте его, в противном случае используйте наименьшее оставшееся значение А , что наименее полезно.

Поскольку нам нужно вернуть свой ответ соответствовать первоначальному заказу B Однако мы не можем просто сортировать Преступность . Мы можем, однако, создать Индекс Заказать Массив поиска и сортировать его в отношении значений в B Затем используйте его как мост между сортировкой А и несортированные B Отказ

Как только мы закончили итерацию, мы можем Вернуть АНС Отказ

Реализация:

JavaScript как обычно должен воспользоваться тем более быстрее напечатанные массивы здесь.

Как отмечалось выше, Python имеет очень короткую, конкурентоспособную версию, использующую биссект и без необходимости сортировать B Отказ

Java придется использовать базовый сортировку на А , как это примитивный массив, но мы можем сделать Орд целочисленный массив, чтобы мы могли использовать лямбда Сортировать. Это означает, что нам придется поменять i и J Отказ

Код JavaScript:

( Перейти к : Описание проблемы Идея решения

var advantageCount = function(A, B) {
    let ord = Uint16Array.from({length:B.length}, (_,i) => i), 
        ans = new Uint32Array(B.length),
        i = 0, j = B.length - 1
    ord.sort((a,b) => B[b] - B[a])
    A.sort((a,b) => b - a)
    for (let ix of ord)
        ans[ix] = A[i] > B[ix] ? A[i++] : A[j--]
    return ans
};

Код Python:

( Перейти к : Описание проблемы Идея решения

class Solution:
    def advantageCount(self, A: List[int], B: List[int]) -> List[int]:
        order = [i for i in range(len(B))]
        ans = [0 for _ in range(len(A))]
        order.sort(key=lambda x: -B[x])
        A.sort()
        for ix in order:
            ans[ix] = A.pop() if A[-1] > B[ix] else A.pop(0)
        return ans

Код Python с/двоичным поиском:

( Перейти к : Описание проблемы Идея решения

class Solution:
    def advantageCount(self, A: List[int], B: List[int]) -> List[int]:
        ans, A = [], sorted(A)
        for num in B:
            val = bisect_right(A, num)
            ans.append(A.pop(0) if val == len(A) else A.pop(val))
        return ans

Java код:

( Перейти к : Описание проблемы Идея решения

class Solution {
    public int[] advantageCount(int[] A, int[] B) {
        Integer[] ord = new Integer[B.length];
        int[] ans = new int[A.length];
        for (int i = 0; i < B.length; i++) ord[i] = i;
        Arrays.sort(ord, (a,b) -> Integer.compare(B[b], B[a]));
        Arrays.sort(A);
        int i = 0, j = B.length - 1;
        for (int ix : ord)
            ans[ix] = A[j] > B[ix] ? A[j--] : A[i++];
        return ans;
    }
}

C ++ код:

( Перейти к : Описание проблемы Идея решения

class Solution {
public:
    vector advantageCount(vector& A, vector& B) {
        vector ord = vector(B.size()), ans = vector(A.size());
        for (int i = 0; i < B.size(); i++) ord[i] = i;
        sort(ord.begin(), ord.end(), [&](int a, int b) {return B[a] > B[b];});
        sort(A.begin(), A.end(), greater<>());
        int i = 0, j = B.size() - 1;
        for (int ix : ord)
            ans[ix] = A[i] > B[ix] ? A[i++] : A[j--];
        return ans;
    }
};

Решения LeetCode (161 часть серии)

Оригинал: “https://dev.to/seanpgallivan/solution-advantage-shuffle-p39”