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

Решение: бинарные деревья с факторами

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

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

Проблема летета # 823 (средний): двоичные деревья с факторами

Описание:

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

Учитывая массив уникальных целых чисел, вырвать , где каждое целое число ARR [I] строго больше, чем 1 Отказ

Мы делаем двоичное дерево, используя эти целые числа, и каждое число может использоваться для любого количества раз. Каждое значение без листного узла должно быть равно продукту значений его детей.

Верните количество бинарных деревьев, которые мы можем сделать. Ответ может быть слишком большим, так что верните ответ модуль 10^9 + 7 .

Примеры:

Вход: art = [2,4]
Вывод: 3
Объяснение: Мы можем сделать эти деревья: [2], [4], [4, 2, 2]
Вход: ar = [2,4,5,10]
Вывод: 7
Объяснение: Мы можем сделать эти деревья: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].

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

  • 1 длиной
  • 2 [я] ^ 9

Идея:

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

Трюк к этой проблеме понимает, что мы можем сломать его на меньшие кусочки. Номер всегда может быть листом, поэтому количество способы Это может сформировать ветку, всегда должно начинаться в 1 Отказ

Если номер может быть сделан из нескольких пар фактор, то способы Наша начальная стоимость 1 Плюс сумма всех способов сделать эти факторы.

Для каждого существующего факторной пары ( FA & FB ), количество способов сделать то, что конкретная конфигурация пара является продуктом количества способов сделать ФА и fb Отказ

Таким образом, мы можем видеть, что каждый номер опирается на первое решение того же вопроса для каждого из его факторов. Это означает, что мы должны начать с сортировки нашего массива номеров ( A ). Тогда мы можем проиграть через A И выяснить каждое число в порядке возрастания, чтобы мы завершили какие-либо факторы для больших чисел, прежде чем нам нужно использовать их.

Это означает хранение информации, которую мы можем сделать в карта Так что мы можем посмотреть результаты по значению.

Чтобы быть более эффективным, когда мы пытаемся найти каждую факторную пару, нам нужно только перейти через А до Квадратный корень Из указанного номера, так что мы не дублируем одни и те же пары фактора, идущие на противоположное направление. Это означает, что нам нужно удвоить каждую пару результат, где ФА и fb не то же самое.

Поскольку каждый номер может быть главой дерева, наш ответ ( ANS ) будет суммой результата каждого номера. Мы не должны забывать модуло на каждом раунде суммирования.

Выполнение:

Java и C ++, набрав переменные, должны использовать долго для способы и анс , но нужно будет бросить и Вернуться к int до возвращения. Им также понадобится дополнительные Продолжить Условный при проверке факторов.

Код JavaScript:

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

var numFactoredBinaryTrees = function(A) {
    A.sort((a,b) => a - b)
    let len = A.length, fmap = new Map(), ans = 0
    for (let i = 0; i < len; i++) {
        let num = A[i], ways = 1, lim = Math.sqrt(num)
        for (let j = 0, fA = A[0]; fA <= lim; fA = A[++j]) {
            let fB = num / fA
            if (fmap.has(fB))
                ways += fmap.get(fA) * fmap.get(fB) * (fA === fB ? 1 : 2)
        }
        fmap.set(num, ways), ans += ways
    }
    return ans % 1000000007
};

Код Python:

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

class Solution:
    def numFactoredBinaryTrees(self, A: List[int]) -> int:
        A.sort()
        fmap, ans = defaultdict(), 0
        for num in A:
            ways, lim = 1, sqrt(num)
            for fA in A:
                if fA > lim: break
                fB = num / fA
                if fB in fmap:
                    ways += fmap[fA] * fmap[fB] * (1 if fA == fB else 2)
            fmap[num], ans = ways, (ans + ways)
        return ans % 1000000007

Java код:

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

class Solution {
    public int numFactoredBinaryTrees(int[] A) {
        Arrays.sort(A);
        int len = A.length;
        long ans = 0;
        HashMap fmap = new HashMap<>();
        for (int num : A) {
            long ways = 1;
            double lim = Math.sqrt(num);
            for (int j = 0, fA = A[0]; fA <= lim; fA = A[++j]) {
                if (num % fA != 0) continue;
                int fB = num / fA;
                if (fmap.containsKey(fB))
                    ways += fmap.get(fA) * fmap.get(fB) * (fA == fB ? 1 : 2);
            }
            fmap.put(num, ways);
            ans = (ans + ways) % 1000000007;
        }
        return (int)ans;
    }
}

C ++ код:

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

class Solution {
public:
    int numFactoredBinaryTrees(vector& A) {
        sort(A.begin(), A.end());
        int len = A.size();
        long ans = 0;
        unordered_map fmap;
        for (int num : A) {
            long ways = 1;
            double lim = sqrt(num);
            for (int j = 0, fA = A[0]; fA <= lim; fA = A[++j]) {
                if (num % fA != 0) continue;
                int fB = num / fA;
                if (fmap.find(fB) != fmap.end())
                    ways += fmap[fA] * fmap[fB] * (fA == fB ? 1 : 2);
            }
            fmap[num] = ways;
            ans = (ans + ways) % 1000000007;
        }
        return (int)ans;
    }
};

Оригинал: “https://dev.to/seanpgallivan/solution-binary-trees-with-factors-2kk4”