Question

我在LeetCode上解决了以下问题：

编写一个取整数n的函数并返回其因子的所有可能组合。例如，12应返回：
      [
      [2,6]，
      [2,2,3]，
      [3,4]
      ]

我提出了以下方法（在C ++中）：

class Solution {
public:
    vector<vector<int>> getFactors(int n) {
        if(n==0 || n==1) return vector<vector<int>>();

        vector<vector<int>> result;
        vector<int> factors;
        getFactorsUtil(result, factors, n, 2);

        return result;
    }

    void getFactorsUtil(vector<vector<int>>& result, vector<int>& factors, int n, int start) {
        long int each=1;
        for(int i=0; i<factors.size(); i++)
            each = each*factors[i];
        if(each==n) result.push_back(factors);
        if(each>n) return;

        for(int i=start; i<=n; i++) {
            if(n%i==0) {        //perfectly divisible
                factors.push_back(i);
                getFactorsUtil(result, factors, n, i);
                factors.pop_back();
            }
        }
    }
};

这可以按预期工作，但在最后一个测试用例上超时：23848713。

一个被接受和赞成的解决方案（Java）如下：

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

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

    for (int i = start; i <= n; ++i) {
        if (n % i == 0) {
            item.add(i);
            helper(result, item, n/i, i);
            item.remove(item.size()-1);
        }
    }
}

两个代码的时间复杂度相同（在我看来）。为什么我的代码失败而其他代码在23848713上成功运行？我的意思是，我的代码中是否有一些明显的错误，或者在线评判是否存在问题？

感谢您的帮助。

修改：我之前的代码<=n中没有for loop condition（仅仅因为其他代码有代码 - 根据问题实际上并不需要它）。我以后把它包括在内。但无论如何，它仍然超时。

Edit2 ：在big-O表示法中，我们跳过了n的系数。我认为这就是它在这里打破的原因。我的代码具有这些常量的大值。我没有其他解释。

Answer 1

由于第一个循环（我将import tkinter as tk root = tk.Tk() cb = tk.Checkbutton(root, onvalue=32) on = tk.Label(root, text=cb['onvalue']) off = tk.Label(root, text=cb['offvalue']) cb.pack() on.pack() off.pack() root.mainloop()中所有数字的乘积计算为factors），因此我的代码高于each。由于这个原因，它失败了。

然而，当我使用值O(n)（而不是n/i）调用它时，我可以通过消除整个循环来完全摆脱O（n）因子。之所以如此，是因为我不再需要检查产品是否等于n。

因此，代码最终因为这种变化而被接受了。感谢。

（发布可能对某人有帮助）。另外，感谢n提示最终引导我的提示。

具有相同时间复杂度的不同行为

1 个答案: