254. Factor Combinations

LeetCode medium original: C# #backtracking #csharp #leetcode #medium

O texto da tarefa é traduzido do russo para o idioma selecionado. O código permanece sem alterações.

LeetCode Static

Числа можно рассматривать как произведение их множителей.

НаExemplo, 8 = 2 x 2 x 2 = 2 x 4.

given inteiro n, return все возможные комбинации его множителей. Вы можете вернуть ответ в любом порядке.

Обратите внимание, что множители должны быть в диапазоне [2, n - 1].

Exemplo:

Input: n = 1

Output: []

C# solução

correspondente/original

using System;
using System.Collections.Generic;
public class Solution {
    private void Backtracking(LinkedList<int> factors, List<IList<int>> ans) {
        if (factors.Count > 1) {
            ans.Add(new List<int>(factors));
        }
        int lastFactor = factors.Last.Value;
        factors.RemoveLast();
        for (int i = factors.Count == 0 ? 2 : factors.Last.Value; i <= lastFactor / i; ++i) {
            if (lastFactor % i == 0) {
                factors.AddLast(i);
                factors.AddLast(lastFactor / i);
                Backtracking(factors, ans);
                factors.RemoveLast();
                factors.RemoveLast();
            }
        }
        factors.AddLast(lastFactor);

C++ solução

rascunho automático, revisar antes de enviar

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    private void Backtracking(LinkedList<int> factors, List<vector<int>> ans) {
        if (factors.size() > 1) {
            ans.push_back(new List<int>(factors));
        }
        int lastFactor = factors.Last.Value;
        factors.RemoveLast();
        for (int i = factors.size() == 0 ? 2 : factors.Last.Value; i <= lastFactor / i; ++i) {
            if (lastFactor % i == 0) {
                factors.AddLast(i);
                factors.AddLast(lastFactor / i);
                Backtracking(factors, ans);
                factors.RemoveLast();
                factors.RemoveLast();
            }
        }
        factors.AddLast(lastFactor);

Java solução

rascunho automático, revisar antes de enviar

import java.util.*;
import java.math.*;

// Auto-generated Java draft from the C# solution. Review API differences before LeetCode submit.
public class Solution {
    private void Backtracking(LinkedList<int> factors, List<List<int>> ans) {
        if (factors.size() > 1) {
            ans.add(new List<int>(factors));
        }
        int lastFactor = factors.Last.Value;
        factors.RemoveLast();
        for (int i = factors.size() == 0 ? 2 : factors.Last.Value; i <= lastFactor / i; ++i) {
            if (lastFactor % i == 0) {
                factors.AddLast(i);
                factors.AddLast(lastFactor / i);
                Backtracking(factors, ans);
                factors.RemoveLast();
                factors.RemoveLast();
            }
        }
        factors.AddLast(lastFactor);

JavaScript solução

correspondente/original

class Solution {
    backtracking(factors, ans) {
        if (factors.length > 1) {
            ans.push([...factors]);
        }
        const lastFactor = factors.pop();
        const start = factors.length === 0 ? 2 : factors[factors.length - 1];
        for (let i = start; i * i <= lastFactor; ++i) {
            if (lastFactor % i === 0) {
                factors.push(i, lastFactor / i);
                this.backtracking(factors, ans);
                factors.pop();
                factors.pop();
            }
        }
        factors.push(lastFactor);
    }

    getFactors(n) {
        const ans = [];
        this.backtracking([n], ans);
        return ans;
    }
}

Go solução

correspondente/original

package main

func backtracking(factors []int, ans *[][]int) {
    if len(factors) > 1 {
        combo := make([]int, len(factors))
        copy(combo, factors)
        *ans = append(*ans, combo)
    }
    lastFactor := factors[len(factors)-1]
    factors = factors[:len(factors)-1]
    start := 2
    if len(factors) > 0 {
        start = factors[len(factors)-1]
    }
    for i := start; i*i <= lastFactor; i++ {
        if lastFactor%i == 0 {
            factors = append(factors, i)
            factors = append(factors, lastFactor/i)
            backtracking(factors, ans)
            factors = factors[:len(factors)-2]
        }
    }
    factors = append(factors, lastFactor)
}

func getFactors(n int) [][]int {
    var ans [][]int
    backtracking([]int{n}, &ans)
    return ans
}

Algorithm

1️⃣

Определите вспомогательную функцию backtracking, которая принимает два параметра: factors (список множителей) и ans (список списков для сохранения всех комбинаций множителей). Начните вызов backtracking с factors, содержащим только n, и пустым списком ans.

2️⃣

Основная логика функции backtracking:

Если размер factors больше 1, добавьте его копию в ans, так как это одно из желаемых решений.

Получите последний element factors (lastFactor) и удалите его из factors.

Если factors пуст, итерируйте i от 2. В противном случае, итерируйте i от последнего значения в factors. Итерируйте, пока i <= lastFactor / i.

Для каждого i, если lastFactor % i == 0, добавьте i и lastFactor / i в factors и вызовите backtracking(factors, ans).

Восстановите список (откат) factors, удалив последние два elementа из factors.

Восстановите список (откат) factors, добавив обратно lastFactor.

3️⃣

В конце выполнения, ans будет содержать все возможные комбинации множителей числа n.

😎

Vacancies for this task

vagas ativas with overlapping task tags are mostradas.

Todas as vagas

Ainda não há vagas ativas.