Question

我正在尝试在leetcode https://leetcode.com/problems/factor-combinations/description/

上解决此问题

数字可视为其因素的乘积。例如

8 = 2 x 2 x 2; = 2 x 4。

编写一个取整数n的函数，并返回其因子的所有可能组合。

虽然我能够使用dfs方法编写代码，但我很难在输入方面驱动其最糟糕的时间复杂度。有人可以帮忙吗？

 public List<List<Integer>> getFactors(int n) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> current = new ArrayList<Integer>();
        getFactorsHelper(n,2,current,result);
        return result;
    }


    public void getFactorsHelper(int n,int start,List<Integer> current, List<List<Integer>> result){
        if(n<=1 && current.size()>1){
            result.add(new ArrayList<>(current));
            return;

        }
        for(int i=start;i<=n;i++){

            if(n%i==0) {
                current.add(i);
                getFactorsHelper(n/i,i,current,result);
                current.remove(current.size()-1);
            }            

        }

    }

Answer 1

我计算了代码的复杂性，如下所示：

让我们考虑runtime的{{1}}是函数getFactorsHelper(n,2)。

在波纹管部分，你有一个T(n)索引的循环。

for(int i=start;i<=n;i++){ if(n%i==0) { current.add(i); getFactorsHelper(n/i,i,current,result); current.remove(current.size()-1); } }在每次迭代中除以n。所以我们有：

（第一次迭代）

（第二次迭代）

getFactorsHelper(n/2,2,current,result) = T(n/2)

（第三次迭代）

getFactorsHelper(n/3,3,current,result) <= getFactorsHelper(n/3,2,current,result) = T(n/3)

<强> ...

（最后一次迭代）

getFactorsHelper(n/4,4,current,result) <= getFactorsHelper(n/4,2,current,result) 
= T(n/4)

总费用

getFactorsHelper(n/n,n,current,result) <= getFactorsHelper(n/n,2,current,result) = T(n/n) = T(1)

解决递归函数

我希望这可以帮到你。

Answer 2

无法在评论中发布解决方案。在这里张贴另一个答案@AliSoltani https://discuss.leetcode.com/topic/30752/my-short-java-solution-which-is-easy-to-understand

public class Solution {
public List<List<Integer>> getFactors(int n) {
    List<List<Integer>> ret = new LinkedList<List<Integer>>();
    if(n <= 3)  return ret;
    List<Integer> path = new LinkedList<Integer>();
    getFactors(2, n, path, ret);
    return ret;
}

private void getFactors(int start, int n, List<Integer> path, List<List<Integer>> ret){
   for(int i = start; i <= Math.sqrt(n); i++){
       if(n % i == 0 && n/i >= i){  // The previous factor is no bigger than the next
           path.add(i);
           path.add(n/i);
           ret.add(new LinkedList<Integer>(path));
           path.remove(path.size() - 1);
           getFactors(i, n/i, path, ret);
           path.remove(path.size() - 1);
       }
   }
}}

如何找到dfs +回溯算法的时间复杂度？

2 个答案: